From f95548a8c40468957d853528bb98e68bd184f25e Mon Sep 17 00:00:00 2001 From: krahets Date: Tue, 2 Apr 2024 19:00:08 +0800 Subject: [PATCH] deploy --- chapter_sorting/merge_sort/index.html | 2 +- .../array_representation_of_tree/index.html | 2 +- en/404.html | 508 ++ .../array/index.html | 508 ++ en/chapter_array_and_linkedlist/index.html | 508 ++ .../linked_list/index.html | 508 ++ .../list/index.html | 508 ++ .../ram_and_cache/index.html | 508 ++ .../summary/index.html | 508 ++ .../index.html | 508 ++ .../iteration_and_recursion/index.html | 508 ++ .../performance_evaluation/index.html | 508 ++ .../space_complexity/index.html | 508 ++ .../summary/index.html | 508 ++ .../time_complexity/index.html | 508 ++ .../basic_data_types/index.html | 508 ++ .../character_encoding/index.html | 508 ++ .../index.html | 508 ++ en/chapter_data_structure/index.html | 508 ++ .../number_encoding/index.html | 508 ++ en/chapter_data_structure/summary/index.html | 508 ++ .../graph.assets/adjacency_list.png | Bin 0 -> 18278 bytes .../graph.assets/adjacency_matrix.png | Bin 0 -> 19729 bytes .../graph.assets/connected_graph.png | Bin 0 -> 11701 bytes .../graph.assets/directed_graph.png | Bin 0 -> 13045 bytes .../graph.assets/linkedlist_tree_graph.png | Bin 0 -> 20366 bytes .../graph.assets/weighted_graph.png | Bin 0 -> 14149 bytes en/chapter_graph/graph/index.html | 2490 ++++++++ .../adjacency_list_step1_initialization.png | Bin 0 -> 19659 bytes .../adjacency_list_step2_add_edge.png | Bin 0 -> 20879 bytes .../adjacency_list_step3_remove_edge.png | Bin 0 -> 19974 bytes .../adjacency_list_step4_add_vertex.png | Bin 0 -> 21387 bytes .../adjacency_list_step5_remove_vertex.png | Bin 0 -> 18618 bytes .../adjacency_matrix_step1_initialization.png | Bin 0 -> 17854 bytes .../adjacency_matrix_step2_add_edge.png | Bin 0 -> 18687 bytes .../adjacency_matrix_step3_remove_edge.png | Bin 0 -> 18885 bytes .../adjacency_matrix_step4_add_vertex.png | Bin 0 -> 22167 bytes .../adjacency_matrix_step5_remove_vertex.png | Bin 0 -> 18332 bytes en/chapter_graph/graph_operations/index.html | 4595 +++++++++++++++ .../graph_traversal.assets/graph_bfs.png | Bin 0 -> 23492 bytes .../graph_bfs_step1.png | Bin 0 -> 19449 bytes .../graph_bfs_step10.png | Bin 0 -> 37007 bytes .../graph_bfs_step11.png | Bin 0 -> 28059 bytes .../graph_bfs_step2.png | Bin 0 -> 30528 bytes .../graph_bfs_step3.png | Bin 0 -> 32946 bytes .../graph_bfs_step4.png | Bin 0 -> 33667 bytes .../graph_bfs_step5.png | Bin 0 -> 36094 bytes .../graph_bfs_step6.png | Bin 0 -> 36265 bytes .../graph_bfs_step7.png | Bin 0 -> 36087 bytes .../graph_bfs_step8.png | Bin 0 -> 37308 bytes .../graph_bfs_step9.png | Bin 0 -> 36931 bytes .../graph_traversal.assets/graph_dfs.png | Bin 0 -> 25724 bytes .../graph_dfs_step1.png | Bin 0 -> 16659 bytes .../graph_dfs_step10.png | Bin 0 -> 29134 bytes .../graph_dfs_step11.png | Bin 0 -> 34071 bytes .../graph_dfs_step2.png | Bin 0 -> 21010 bytes .../graph_dfs_step3.png | Bin 0 -> 21987 bytes .../graph_dfs_step4.png | Bin 0 -> 22780 bytes .../graph_dfs_step5.png | Bin 0 -> 23368 bytes .../graph_dfs_step6.png | Bin 0 -> 25699 bytes .../graph_dfs_step7.png | Bin 0 -> 24425 bytes .../graph_dfs_step8.png | Bin 0 -> 27335 bytes .../graph_dfs_step9.png | Bin 0 -> 32797 bytes en/chapter_graph/graph_traversal/index.html | 3324 +++++++++++ en/chapter_graph/index.html | 2273 ++++++++ en/chapter_graph/summary/index.html | 2310 ++++++++ en/chapter_hashing/hash_algorithm/index.html | 508 ++ en/chapter_hashing/hash_collision/index.html | 508 ++ en/chapter_hashing/hash_map/index.html | 508 ++ en/chapter_hashing/index.html | 508 ++ en/chapter_hashing/summary/index.html | 547 ++ .../heapify_operations_count.png | Bin 0 -> 16135 bytes en/chapter_heap/build_heap/index.html | 2676 +++++++++ .../heap.assets/heap_pop_step1.png | Bin 0 -> 20561 bytes .../heap.assets/heap_pop_step10.png | Bin 0 -> 25204 bytes .../heap.assets/heap_pop_step2.png | Bin 0 -> 20925 bytes .../heap.assets/heap_pop_step3.png | Bin 0 -> 19241 bytes .../heap.assets/heap_pop_step4.png | Bin 0 -> 27314 bytes .../heap.assets/heap_pop_step5.png | Bin 0 -> 28857 bytes .../heap.assets/heap_pop_step6.png | Bin 0 -> 29412 bytes .../heap.assets/heap_pop_step7.png | Bin 0 -> 31070 bytes .../heap.assets/heap_pop_step8.png | Bin 0 -> 31541 bytes .../heap.assets/heap_pop_step9.png | Bin 0 -> 33486 bytes .../heap.assets/heap_push_step1.png | Bin 0 -> 17672 bytes .../heap.assets/heap_push_step2.png | Bin 0 -> 18674 bytes .../heap.assets/heap_push_step3.png | Bin 0 -> 24734 bytes .../heap.assets/heap_push_step4.png | Bin 0 -> 26950 bytes .../heap.assets/heap_push_step5.png | Bin 0 -> 26209 bytes .../heap.assets/heap_push_step6.png | Bin 0 -> 27387 bytes .../heap.assets/heap_push_step7.png | Bin 0 -> 26490 bytes .../heap.assets/heap_push_step8.png | Bin 0 -> 27279 bytes .../heap.assets/heap_push_step9.png | Bin 0 -> 23567 bytes .../heap.assets/min_heap_and_max_heap.png | Bin 0 -> 22098 bytes .../heap.assets/representation_of_heap.png | Bin 0 -> 34060 bytes en/chapter_heap/heap/index.html | 4134 ++++++++++++++ en/chapter_heap/index.html | 2273 ++++++++ en/chapter_heap/summary/index.html | 2340 ++++++++ .../top_k.assets/top_k_heap_step1.png | Bin 0 -> 13981 bytes .../top_k.assets/top_k_heap_step2.png | Bin 0 -> 15081 bytes .../top_k.assets/top_k_heap_step3.png | Bin 0 -> 16415 bytes .../top_k.assets/top_k_heap_step4.png | Bin 0 -> 19834 bytes .../top_k.assets/top_k_heap_step5.png | Bin 0 -> 20727 bytes .../top_k.assets/top_k_heap_step6.png | Bin 0 -> 23325 bytes .../top_k.assets/top_k_heap_step7.png | Bin 0 -> 19953 bytes .../top_k.assets/top_k_heap_step8.png | Bin 0 -> 20750 bytes .../top_k.assets/top_k_heap_step9.png | Bin 0 -> 16006 bytes .../top_k.assets/top_k_sorting.png | Bin 0 -> 10160 bytes .../top_k.assets/top_k_traversal.png | Bin 0 -> 17271 bytes en/chapter_heap/top_k/index.html | 2763 +++++++++ .../algorithms_are_everywhere/index.html | 508 ++ en/chapter_introduction/index.html | 508 ++ en/chapter_introduction/summary/index.html | 508 ++ .../what_is_dsa/index.html | 508 ++ en/chapter_preface/about_the_book/index.html | 508 ++ en/chapter_preface/index.html | 508 ++ en/chapter_preface/suggestions/index.html | 508 ++ en/chapter_preface/summary/index.html | 508 ++ en/chapter_stack_and_queue/deque/index.html | 508 ++ en/chapter_stack_and_queue/index.html | 508 ++ en/chapter_stack_and_queue/queue/index.html | 508 ++ en/chapter_stack_and_queue/stack/index.html | 508 ++ en/chapter_stack_and_queue/summary/index.html | 508 ++ .../array_representation_binary_tree.png | Bin 0 -> 27870 bytes ...ay_representation_complete_binary_tree.png | Bin 0 -> 19214 bytes .../array_representation_with_empty.png | Bin 0 -> 22549 bytes .../array_representation_without_empty.png | Bin 0 -> 19308 bytes .../array_representation_of_tree/index.html | 3555 ++++++++++++ ...vltree_degradation_from_inserting_node.png | Bin 0 -> 14784 bytes ...avltree_degradation_from_removing_node.png | Bin 0 -> 15441 bytes .../avltree_left_right_rotate.png | Bin 0 -> 21615 bytes .../avl_tree.assets/avltree_left_rotate.png | Bin 0 -> 21444 bytes .../avltree_left_rotate_with_grandchild.png | Bin 0 -> 25314 bytes .../avltree_right_left_rotate.png | Bin 0 -> 22150 bytes .../avltree_right_rotate_step1.png | Bin 0 -> 10017 bytes .../avltree_right_rotate_step2.png | Bin 0 -> 15950 bytes .../avltree_right_rotate_step3.png | Bin 0 -> 17700 bytes .../avltree_right_rotate_step4.png | Bin 0 -> 22050 bytes .../avltree_right_rotate_with_grandchild.png | Bin 0 -> 25747 bytes .../avltree_rotation_cases.png | Bin 0 -> 22171 bytes en/chapter_tree/avl_tree/index.html | 5054 +++++++++++++++++ .../binary_search_tree.png | Bin 0 -> 11901 bytes .../bst_degradation.png | Bin 0 -> 16322 bytes .../bst_inorder_traversal.png | Bin 0 -> 31242 bytes .../binary_search_tree.assets/bst_insert.png | Bin 0 -> 25863 bytes .../bst_remove_case1.png | Bin 0 -> 28514 bytes .../bst_remove_case2.png | Bin 0 -> 27172 bytes .../bst_remove_case3_step1.png | Bin 0 -> 16431 bytes .../bst_remove_case3_step2.png | Bin 0 -> 26887 bytes .../bst_remove_case3_step3.png | Bin 0 -> 27593 bytes .../bst_remove_case3_step4.png | Bin 0 -> 30089 bytes .../bst_search_step1.png | Bin 0 -> 14103 bytes .../bst_search_step2.png | Bin 0 -> 14519 bytes .../bst_search_step3.png | Bin 0 -> 15495 bytes .../bst_search_step4.png | Bin 0 -> 16539 bytes en/chapter_tree/binary_search_tree/index.html | 3980 +++++++++++++ .../balanced_binary_tree.png | Bin 0 -> 16001 bytes .../binary_tree_add_remove.png | Bin 0 -> 20652 bytes .../binary_tree_best_worst_cases.png | Bin 0 -> 17221 bytes .../binary_tree_definition.png | Bin 0 -> 24034 bytes .../binary_tree_terminology.png | Bin 0 -> 20217 bytes .../complete_binary_tree.png | Bin 0 -> 14111 bytes .../binary_tree.assets/full_binary_tree.png | Bin 0 -> 10974 bytes .../perfect_binary_tree.png | Bin 0 -> 15374 bytes en/chapter_tree/binary_tree/index.html | 3098 ++++++++++ .../binary_tree_bfs.png | Bin 0 -> 15450 bytes .../binary_tree_dfs.png | Bin 0 -> 43171 bytes .../preorder_step1.png | Bin 0 -> 16170 bytes .../preorder_step10.png | Bin 0 -> 25164 bytes .../preorder_step11.png | Bin 0 -> 26621 bytes .../preorder_step2.png | Bin 0 -> 17455 bytes .../preorder_step3.png | Bin 0 -> 18579 bytes .../preorder_step4.png | Bin 0 -> 19197 bytes .../preorder_step5.png | Bin 0 -> 20436 bytes .../preorder_step6.png | Bin 0 -> 21722 bytes .../preorder_step7.png | Bin 0 -> 22734 bytes .../preorder_step8.png | Bin 0 -> 23670 bytes .../preorder_step9.png | Bin 0 -> 24191 bytes .../binary_tree_traversal/index.html | 3243 +++++++++++ en/chapter_tree/index.html | 2275 ++++++++ en/chapter_tree/summary/index.html | 2363 ++++++++ en/index.html | 508 ++ en/search/search_index.json | 2 +- en/sitemap.xml | 159 +- en/sitemap.xml.gz | Bin 508 -> 598 bytes search/search_index.json | 2 +- sitemap.xml | 210 +- sitemap.xml.gz | Bin 1004 -> 1004 bytes 187 files changed, 72320 insertions(+), 146 deletions(-) create mode 100644 en/chapter_graph/graph.assets/adjacency_list.png create mode 100644 en/chapter_graph/graph.assets/adjacency_matrix.png create mode 100644 en/chapter_graph/graph.assets/connected_graph.png create mode 100644 en/chapter_graph/graph.assets/directed_graph.png create mode 100644 en/chapter_graph/graph.assets/linkedlist_tree_graph.png create mode 100644 en/chapter_graph/graph.assets/weighted_graph.png create mode 100644 en/chapter_graph/graph/index.html create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_list_step1_initialization.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_list_step2_add_edge.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_list_step3_remove_edge.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_list_step4_add_vertex.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_list_step5_remove_vertex.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_matrix_step1_initialization.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_matrix_step2_add_edge.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_matrix_step3_remove_edge.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_matrix_step4_add_vertex.png create mode 100644 en/chapter_graph/graph_operations.assets/adjacency_matrix_step5_remove_vertex.png create mode 100644 en/chapter_graph/graph_operations/index.html create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step1.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step10.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step11.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step2.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step3.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step4.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step5.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step6.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step7.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step8.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_bfs_step9.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step1.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step10.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step11.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step2.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step3.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step4.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step5.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step6.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step7.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step8.png create mode 100644 en/chapter_graph/graph_traversal.assets/graph_dfs_step9.png create mode 100644 en/chapter_graph/graph_traversal/index.html create mode 100644 en/chapter_graph/index.html create mode 100644 en/chapter_graph/summary/index.html create mode 100644 en/chapter_heap/build_heap.assets/heapify_operations_count.png create mode 100644 en/chapter_heap/build_heap/index.html create mode 100644 en/chapter_heap/heap.assets/heap_pop_step1.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step10.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step2.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step3.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step4.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step5.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step6.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step7.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step8.png create mode 100644 en/chapter_heap/heap.assets/heap_pop_step9.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step1.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step2.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step3.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step4.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step5.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step6.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step7.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step8.png create mode 100644 en/chapter_heap/heap.assets/heap_push_step9.png create mode 100644 en/chapter_heap/heap.assets/min_heap_and_max_heap.png create mode 100644 en/chapter_heap/heap.assets/representation_of_heap.png create mode 100644 en/chapter_heap/heap/index.html create mode 100644 en/chapter_heap/index.html create mode 100644 en/chapter_heap/summary/index.html create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step1.png create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step2.png create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step3.png create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step4.png create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step5.png create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step6.png create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step7.png create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step8.png create mode 100644 en/chapter_heap/top_k.assets/top_k_heap_step9.png create mode 100644 en/chapter_heap/top_k.assets/top_k_sorting.png create mode 100644 en/chapter_heap/top_k.assets/top_k_traversal.png create mode 100644 en/chapter_heap/top_k/index.html create mode 100644 en/chapter_tree/array_representation_of_tree.assets/array_representation_binary_tree.png create mode 100644 en/chapter_tree/array_representation_of_tree.assets/array_representation_complete_binary_tree.png create mode 100644 en/chapter_tree/array_representation_of_tree.assets/array_representation_with_empty.png create mode 100644 en/chapter_tree/array_representation_of_tree.assets/array_representation_without_empty.png create mode 100644 en/chapter_tree/array_representation_of_tree/index.html create mode 100644 en/chapter_tree/avl_tree.assets/avltree_degradation_from_inserting_node.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_degradation_from_removing_node.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_left_right_rotate.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_left_rotate.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_left_rotate_with_grandchild.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_right_left_rotate.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_right_rotate_step1.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_right_rotate_step2.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_right_rotate_step3.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_right_rotate_step4.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_right_rotate_with_grandchild.png create mode 100644 en/chapter_tree/avl_tree.assets/avltree_rotation_cases.png create mode 100644 en/chapter_tree/avl_tree/index.html create mode 100644 en/chapter_tree/binary_search_tree.assets/binary_search_tree.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_degradation.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_inorder_traversal.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_insert.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_remove_case1.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_remove_case2.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step1.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step2.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step3.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step4.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_search_step1.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_search_step2.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_search_step3.png create mode 100644 en/chapter_tree/binary_search_tree.assets/bst_search_step4.png create mode 100644 en/chapter_tree/binary_search_tree/index.html create mode 100644 en/chapter_tree/binary_tree.assets/balanced_binary_tree.png create mode 100644 en/chapter_tree/binary_tree.assets/binary_tree_add_remove.png create mode 100644 en/chapter_tree/binary_tree.assets/binary_tree_best_worst_cases.png create mode 100644 en/chapter_tree/binary_tree.assets/binary_tree_definition.png create mode 100644 en/chapter_tree/binary_tree.assets/binary_tree_terminology.png create mode 100644 en/chapter_tree/binary_tree.assets/complete_binary_tree.png create mode 100644 en/chapter_tree/binary_tree.assets/full_binary_tree.png create mode 100644 en/chapter_tree/binary_tree.assets/perfect_binary_tree.png create mode 100644 en/chapter_tree/binary_tree/index.html create mode 100644 en/chapter_tree/binary_tree_traversal.assets/binary_tree_bfs.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/binary_tree_dfs.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step1.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step10.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step11.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step2.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step3.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step4.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step5.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step6.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step7.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step8.png create mode 100644 en/chapter_tree/binary_tree_traversal.assets/preorder_step9.png create mode 100644 en/chapter_tree/binary_tree_traversal/index.html create mode 100644 en/chapter_tree/index.html create mode 100644 en/chapter_tree/summary/index.html diff --git a/chapter_sorting/merge_sort/index.html b/chapter_sorting/merge_sort/index.html index f6bb50458..c8914acaf 100644 --- a/chapter_sorting/merge_sort/index.html +++ b/chapter_sorting/merge_sort/index.html @@ -4089,7 +4089,7 @@ // 当左右子数组都还有元素时，进行比较并将较小的元素复制到临时数组中 while i <= mid && j <= right { if nums[i] <= nums[j] { - tmp[k] = nums[j]; + tmp[k] = nums[i]; i += 1; } else { tmp[k] = nums[j]; diff --git a/chapter_tree/array_representation_of_tree/index.html b/chapter_tree/array_representation_of_tree/index.html index fede23803..7adc63c5e 100644 --- a/chapter_tree/array_representation_of_tree/index.html +++ b/chapter_tree/array_representation_of_tree/index.html @@ -3627,7 +3627,7 @@

完美二叉树的数组表示

图 7-12   完美二叉树的数组表示

-

映射公式的角色相当于链表中的引用。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左（右）子节点。

+

映射公式的角色相当于链表中的节点引用（指针）。给定数组中的任意一个节点，我们都可以通过映射公式来访问它的左（右）子节点。

7.3.2   表示任意二叉树

完美二叉树是一个特例，在二叉树的中间层通常存在许多 None 。由于层序遍历序列并不包含这些 None ，因此我们无法仅凭该序列来推测 None 的数量和分布位置。这意味着存在多种二叉树结构都符合该层序遍历序列。

如图 7-13 所示，给定一棵非完美二叉树，上述数组表示方法已经失效。

diff --git a/en/404.html b/en/404.html index 9273d2a5c..461f1d692 100644 --- a/en/404.html +++ b/en/404.html @@ -1400,6 +1400,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_array_and_linkedlist/array/index.html b/en/chapter_array_and_linkedlist/array/index.html index d1527d681..fc543a523 100644 --- a/en/chapter_array_and_linkedlist/array/index.html +++ b/en/chapter_array_and_linkedlist/array/index.html @@ -1560,6 +1560,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_array_and_linkedlist/index.html b/en/chapter_array_and_linkedlist/index.html index 83f3eed70..eab881f65 100644 --- a/en/chapter_array_and_linkedlist/index.html +++ b/en/chapter_array_and_linkedlist/index.html @@ -1424,6 +1424,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_array_and_linkedlist/linked_list/index.html b/en/chapter_array_and_linkedlist/linked_list/index.html index 6bb170e96..2ba3a4482 100644 --- a/en/chapter_array_and_linkedlist/linked_list/index.html +++ b/en/chapter_array_and_linkedlist/linked_list/index.html @@ -1551,6 +1551,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_array_and_linkedlist/list/index.html b/en/chapter_array_and_linkedlist/list/index.html index 3b8c647bb..4953a9aa1 100644 --- a/en/chapter_array_and_linkedlist/list/index.html +++ b/en/chapter_array_and_linkedlist/list/index.html @@ -1542,6 +1542,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_array_and_linkedlist/ram_and_cache/index.html b/en/chapter_array_and_linkedlist/ram_and_cache/index.html index 05d5a1f0b..bc434ab15 100644 --- a/en/chapter_array_and_linkedlist/ram_and_cache/index.html +++ b/en/chapter_array_and_linkedlist/ram_and_cache/index.html @@ -1491,6 +1491,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_array_and_linkedlist/summary/index.html b/en/chapter_array_and_linkedlist/summary/index.html index 3bf704ffc..52cca6857 100644 --- a/en/chapter_array_and_linkedlist/summary/index.html +++ b/en/chapter_array_and_linkedlist/summary/index.html @@ -1482,6 +1482,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_computational_complexity/index.html b/en/chapter_computational_complexity/index.html index 1dd748fb8..1ecaece64 100644 --- a/en/chapter_computational_complexity/index.html +++ b/en/chapter_computational_complexity/index.html @@ -1424,6 +1424,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_computational_complexity/iteration_and_recursion/index.html b/en/chapter_computational_complexity/iteration_and_recursion/index.html index 4fc51ff31..3f128f6a7 100644 --- a/en/chapter_computational_complexity/iteration_and_recursion/index.html +++ b/en/chapter_computational_complexity/iteration_and_recursion/index.html @@ -1557,6 +1557,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_computational_complexity/performance_evaluation/index.html b/en/chapter_computational_complexity/performance_evaluation/index.html index 5c0b5dcf3..632f9f3ec 100644 --- a/en/chapter_computational_complexity/performance_evaluation/index.html +++ b/en/chapter_computational_complexity/performance_evaluation/index.html @@ -1482,6 +1482,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_computational_complexity/space_complexity/index.html b/en/chapter_computational_complexity/space_complexity/index.html index 5d6dd6bfb..0a3521eda 100644 --- a/en/chapter_computational_complexity/space_complexity/index.html +++ b/en/chapter_computational_complexity/space_complexity/index.html @@ -1551,6 +1551,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_computational_complexity/summary/index.html b/en/chapter_computational_complexity/summary/index.html index 2c0c67507..415885631 100644 --- a/en/chapter_computational_complexity/summary/index.html +++ b/en/chapter_computational_complexity/summary/index.html @@ -1482,6 +1482,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_computational_complexity/time_complexity/index.html b/en/chapter_computational_complexity/time_complexity/index.html index aea95d599..ee9669bb5 100644 --- a/en/chapter_computational_complexity/time_complexity/index.html +++ b/en/chapter_computational_complexity/time_complexity/index.html @@ -1602,6 +1602,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_data_structure/basic_data_types/index.html b/en/chapter_data_structure/basic_data_types/index.html index 207bbfa8f..0d037e268 100644 --- a/en/chapter_data_structure/basic_data_types/index.html +++ b/en/chapter_data_structure/basic_data_types/index.html @@ -1434,6 +1434,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_data_structure/character_encoding/index.html b/en/chapter_data_structure/character_encoding/index.html index f9fc17131..a77ed7e0f 100644 --- a/en/chapter_data_structure/character_encoding/index.html +++ b/en/chapter_data_structure/character_encoding/index.html @@ -1509,6 +1509,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_data_structure/classification_of_data_structure/index.html b/en/chapter_data_structure/classification_of_data_structure/index.html index c5b5c8bea..da59b3c85 100644 --- a/en/chapter_data_structure/classification_of_data_structure/index.html +++ b/en/chapter_data_structure/classification_of_data_structure/index.html @@ -1482,6 +1482,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_data_structure/index.html b/en/chapter_data_structure/index.html index 8bdc8263e..323cf3802 100644 --- a/en/chapter_data_structure/index.html +++ b/en/chapter_data_structure/index.html @@ -1424,6 +1424,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_data_structure/number_encoding/index.html b/en/chapter_data_structure/number_encoding/index.html index ba00e43c1..3fbc2b723 100644 --- a/en/chapter_data_structure/number_encoding/index.html +++ b/en/chapter_data_structure/number_encoding/index.html @@ -1482,6 +1482,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_data_structure/summary/index.html b/en/chapter_data_structure/summary/index.html index b533a73e7..4f8e75150 100644 --- a/en/chapter_data_structure/summary/index.html +++ b/en/chapter_data_structure/summary/index.html @@ -1482,6 +1482,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_graph/graph.assets/adjacency_list.png b/en/chapter_graph/graph.assets/adjacency_list.png new file mode 100644 index 0000000000000000000000000000000000000000..6be64bc17044a608258ff5b78664f645a88f39ac GIT binary patch literal 18278 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 R2KhN4uBWS?%Q~loCIDr0u1x>{ literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph.assets/adjacency_matrix.png b/en/chapter_graph/graph.assets/adjacency_matrix.png new file mode 100644 index 0000000000000000000000000000000000000000..a70ee0db46c4b1eacfa58b8bb5c2f75297f27e27 GIT binary patch literal 19729 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph.assets/connected_graph.png b/en/chapter_graph/graph.assets/connected_graph.png new file mode 100644 index 0000000000000000000000000000000000000000..3d3dc1b6936d59f2640ffd3608308546537cb135 GIT binary patch literal 11701 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 =2i5ctfd$k3hG!Y|DIUxqv107t!` zE`|Q)ocYmT3m(J5dvdfZ_smNIPM;Xvdv3h^?9jjV`P=vJeMgSJ>GLh?)^#A%&Je&c zf44(0QI E0Td&J{{R30 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph.assets/linkedlist_tree_graph.png b/en/chapter_graph/graph.assets/linkedlist_tree_graph.png new file mode 100644 index 0000000000000000000000000000000000000000..2e3f9b7c0b4127c446f8e0987a00e90547b26723 GIT binary patch literal 20366 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 z000000000000000000000000000000003C+!65+v004lX|F3;v0ssI2003YY|D8qg TTHq%B00000NkvXXu0mjfVUwM+ literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph.assets/weighted_graph.png b/en/chapter_graph/graph.assets/weighted_graph.png new file mode 100644 index 0000000000000000000000000000000000000000..63d6934d6bea1cd0f338c1ca9570a3a6a2311a8a GIT binary patch literal 14149 zcmbVz1yodzx9$uBLpPFA!w@1}(heovC<0P~h_rMwgmex_2uKS`cL@$ijndNH-5?!r z_}%|q@80{?d+WY?)~uPc&;E9Od(S!RRD_m>A|W0v9smF!R92GL0RXVjs~CegAoS09 z9=9a`02I(t(^I&+y9;UxjEIPkkdQ#mAai?j7WU>lIywpq3l|p`Z*Fc{TU)QLug)*d zKYsk!-`~H!zK%kn4i68vwzksK)BpVWGdMU{TU(1nA~Q2H%gf92^YefA{$5#GiHnOn zK0Z!OP3`LHii(OF9UV$;r9Ayj)mVn3~YHn`+{{4GE zK)~O>f5*qi&(6*g6BDztvQAG=zkdC?ySr;|Z@;s%6B83tHe5P9JS;6OJvlj9RaIqR zU~q77AR{9a`6I&B)m1@3AvQKvRaG@K_rt`*L_=f4hwmX478bg?x?S^K2WJP{C)-oo zQ~Ue-3GML%s{>#93qEzH85q8SCivv0mqeZ{z6{huvnrwg!uEPL*1N%fxp zkCzWpq9p(LISR1H{2zOH{@k3H2=m?#{MwXG=KtyEgJ1KuG7C-~!1vVBD&L5bAe%y) zq9g7+u+m0IFBCILsmc@hki; zLECT}s$BCzg&Ed{9WApV$Hz%*eN2P1_>(&Gd%;f|j{~5ERyWBfiS+G9uXr>WnobjI zYzrQMwpQU)pbwgkCco{XAK8>8;n{X#GV+0I2^LQxR;;mqY(C__TfuC!Fl;Vb5RN6Z zK5mIegpYQPSv9J2rXJlx{}L?vwlB&AYZ`NHnpBVO$BBy7;#Xv)KYtbAEtZ||Z|IA? z*fjmE`T2ERX)}T?+IHqJ^;ZdgT#a@@W$w|urV{~QLF=rfpjj$79 z8d$99Yx#yhSSFR&&4DUp4yhLHOi$-DEGN9~pyC4y6Xof_39kA@`qhDcosiQc{Y(%gs^;c}LL=w>PiQ<`zlb}_hWq{;_`e}QNlbx8WH z*2`bK^B{N;#cM`jL*I_&$iJpfAQ~#?{X36>_fz%c?M)andz=aI`R#T=Qj$E^pV*~_ z=De1@?E5TgiOhSSiO}b7R1${KC>nEFvN%|tU45N+ign6@-sVGdhYMl~0*`(Qw!-;~ z0&vcB_k_RLxoKHz^t`jVV`+cEZ0e`DVpgo^aD`cd&{S0pkrIot!uIh5qlw+;3)v$? z35FDB65u}-cbc9>T{CFwqu2*z{Hr|5 zq|`CBsil1csz=oEi#%m&IG0%Aw7eW`Y;0EKI`$Z>AJ}Su->>iHvzsOIX9b#Fw7uf6mzK)xZxQLiIj6qfb7ESHsUCo(dpNB@9Sa;c3PAwvR}pV^t&Z#JmLi z2@l*D_URL=VoRugD{HIN0_t-cf^-}60Q;ku%V{h5t&=|91C{RtWYjfzul@ANl zCaJZFA1Fv?wh4S2SOPiOsHs-mJ&H2Jn4)EZ0?F<7LQLF2dWU|xNX*`M@B-`%ECKFK zpE-uw-@HM%*0%6?ObVfHk|)UFdXFPoGt;bE6=G3*OCy93ayTmf58!9nUeae`B?U!% zAc~Oh@d9ZlW*GBK-C`>ag3jy((jpfgej3Mw+kha9-=KDwhJn=RgT;cNOvjrBLtyIp zk(JHC8f?4FqG!}1-)Ly^(${br>N@7`tNx-_KN{E1DNE*5K%1ST=$cAT;y&OBQnRj& z5Rb=v)drqmJ`%(b5ZrkNiWY?qqc;^uAp<*hqv1c+%+5;ofwZULwCL>l*$I9UY4Z}i zDV}8)?c_sIq_!g64cbQByeYLDQgp83}T{uYJx-2$y-!+1-}tt)%*JfSovG9I=Ki=Mr26D>eco5xp%j3 z_tA9pHgC9e$~k!ZtK7TD&`N{V5QFE3v#8SB>kegIt8QeuspkwH2p>$I)(+BaJ!my;=atK zF%buhrND|L2!Ru$)`PxvbqLD#Rw?d6ko(wz_DxH_+uB9U2|%gq%(acsAy+Aj3yLk| zZpz{`%B8IUBHKhky?Q@RO*z9};qQNVv6Nqy((3ikYtvZflo1 zFyb_-M}45D;7dB87T*?K%LJ`Y^Cb26?027^>^TK$bJQm&MP^G>D#(md^XkX#Sjem zlB)RX0#i4S_!C8vs(dmdgA-`l_;NfcUXR$^bFPwG=IE~o^jyawXtwAyRei+h_t zW}X1TyUSu{Go(MlaYesQiINMhLaqn(FrLAEdu?x35FW%f!7^_A)C@BOq1c`n*QW71 z;pZuPJMpKVG^k?tKwSYu$UpG{k%KFaLVjv6H?O;3=t7YAr=!^+>5HkW#S!oski6Es zJ|_c`#ESb>)u={;O&LoWhWAHY@3W}CYnsdB;48R1W;5ZN2aDW@9EHJ~P9Yv9}0UtWcfu`*|pYbB&XnQN8z$W`}+Q z8G_pPHeW{$+KDVni3B3f+0393N6fe!ID)z%9Ym>&gK$B9N+w(=(4v^da8Grn>pk}4 zcuWNR{U|B7hd=D0M+Hck371-*e#p5H^!l-rjEZX&MdGiMr18)0&e?mu&B)_(TbIWFv-Foq;W9&AH>R!DLf8sMcnxv{=krvvpNEl5ia_ zq-v`)6R#DXfhHDc7xjI%$|1%6BHL)K$)|%5Ap%W~`=JLDaJ@>ItaV0{5ms??9C>{B zJU-LSXp88Hl41OebobkA%J}fp^Dj=F_g-Y|0;*k}O1=Y`KkN>;Dd2O@Q^M?~u8w`W z1=(6kYOv%IjKUpC*r242NEKVY3Ls8@`4eM2#%fA(eEW=0tDSw|Zy90WUZNV`t?X|$ z5|2nIEdnLJan1T9P>CQ0D!)u=L3iFx9%Dzp7cvX_qLdqrOoYS4f$HJ+I?JoMQa5rw zg(}ZU3BV~czYu~X#wd0-`b8as2b;F0tPV7a>iYVQORzGeCLA|UFwSTKOZt_A*;qSn zDkP#oWh%U5P)SzE;Za>c-q`Q4<$ktz0f`VVC)PGhwKyOPdrUu=0;jAtc|MB}g4rK~5ITqZZh7S{Cyt|8y z%J&M=j}u-xuPvd>wDknje+p*1Mx_*vlvJuVUE+I`^N-mb5~$ASZ@lX4=ef-yR}zve z$wK}uG15AAHG1Q`sP|7#D76kw*?wGpFUq!c+_q4riM4F>Y67e8tIFWX9A=Qu6DY>k zl~_YXJB|>kw6BAaRC><%8*ZIw@GjmX~f<8E! zE4^w|D*1;^e!zadjd=fZaUL(rxq50Q*mhg&R3-JRD^j*#sd`9+8U^-g9`Jp^mwx7~ z^D#y;=(V;p*tJjYwc>qYAwcR@kb59wti=q2XK=0Lsn}DNQ|Cs%1@%D1HOM1`5z^>L z@PuCdhcTDRB}3WO8gnJfeY@HL1oObG<-SUCofkVU3&K@|lFU8~Ryufq&y{982;(up z0Q-23ePbI09ZvxK>Nx%-nR0j+w>Q8&kdB>;s!VHodS`X<;<+>Sl*wUjqmpfh!+0jPHC)kf% zyh|^Q-!#?2iBv#6IQVmc>t;turV2q10V^?babRf4SugpWp0ucnNPR0l{ntw< zL*rKMw=Hs9^>30l!<8H~MblJRtsqeKzsfTQh!bT8V6XW)cL=)H0A)>&%LP3oAX;Pd zz`bGKv?zJu^O}BLA+PMGcXm7Xy?l%GbT*Xa!;fH12(g|C!Zte?PZ{qbM6Q>NT@YEn zH@d-9aK}39%*o$x+m`4TrH2dLPb@0|GQO`*>>zJ?m-CeeZ_L!J zU4p-Xc?{Q9f6w`lH8lO?g6OH|mV8>$WgLYjD zu_gJ-B^l||@Y zvxAK;_k{rwrX>FxeyIbv#A<1NzbiVG6S=Pj(%6*Bw+SKL2q9 zMYcUO%}PP>vBQJ9o4w|Af;-BfPc##QPm({l5flU0s*P%#Cg*_Ti#(S?3_-CNfh_gj%(RBC7*^-Ry!Y`Z(YMf`UFLB}GF2 zT+1o4IIz}*nP7-JyPux+5a%DGn#k6y9RPk*fPm}p& zZik;d^CVW@fx-!xsx7ivWDDc2yJ_TGIAu$nn$8mpXY69b@@(lJmL&Ve&UlaMAJ!g& z8`}NeRlodcFX!Xq3O@Wfkq@AH!}N|9Xq=!V&}Sh2i&iVfKFeV`tqB<0pMAzB@(3v# zPoTAg6PEk9=U&YxH@#-v{g&iuv^rh|1r$1M>L|GgekoTsJTwCLw!{8f*DC5#^Y7so zFH7mDRAGpG`S{ceE$MZ;yu5Ef;mO;R$8GKviV_0BNk1njXVzqKl{Wf#-_^I?{sh4Y zCuI~hL0gqlnFsq*cHyYgz#gMK`hO~3Px&3T|E1pRwh{+geQS$^-~K_+yPgPTQ%(oG zx$7(cviPdxHt31_4OOPhmbqQuRf5DDCNEPDBl!rH;B?EfNd-l9&{oClueC=P)DGj4 zAc4QPEN=HSV766}KxMcZf<#cSs?%c;;1M$;OGd3=L#Jl$ibtt4lPrQtV$tf(Q9qJ` zLTtd(N#}zjS#9b9N+8{v&t8G?6Rw$Tzv|%Zw+S64JrDVU=#|eb3|49Os(a zeG9pu+bWnSQ`Q$xP_M`f@^XNRwNjaOAGwV#ejK)O?R3!enA@eZ_i4L1b@Y~(JqWY> z9sIf`tEyv@!x~v>*Zl^6e~%`6_Ea@9@L^ZoO@8B*2Qj_^+1O{G_-`cvb;isgIw!8_ zSw%vectFJH$si5mnP^>ez4yI1don~r?=gkJd^Hb1B?E8;#4~C8^o}vc=e8ERz)J8A z&r>x;CtDLH%ebc?CK-1&muYT?7W@nirgS)_5*}*K9^at=KV;|dEdZ*-H97s+ImT!i zfH(glEFLC~&H`?gZEz<8-!0yw5}Ea`NR&pF273tnaz z1~l9OElprBOK{%{&ePg6hgeH_p`QV`@k~?p_cEn9_eSSVa#M%p z@eA$4Q3)-@6WHPJwW2dc-s8m3BaZe_IyVSFF`o9<)P1AqEPvYPAUBoR=OXrFN6S5Nn}h%-6bO0+vfe3ju( zo{-2!{04q_t(^LtqcPs#(Svt9AsoXFEFPcWc6A@_rV&3R79jnQY!p>Hg0HwU`FEnT zc^s9q1ioivpNWNPvUoPmF*mjz7jCto-B+TziCh{^ifEl&r$&A7if)UjidjSgR62Vy zPY7s0#s;h_6*+nvrQwIhOwtfv_D?4(f$zC&tZJ(945<{qL{9;U1< zZe23fXs8O$Wp%|$B053{DZ8&SOnyxD!wkQ3oG#e1npl@X6{1|md+TD3qB?a-4iSs4 z91FMiC`1ya3ZOmg>T;s>{z?-do~b-Dz2|O&P%#F8O=n8WzlQSTfTmaIS zr04+ALWU)*# zN;$RH3VSF{&!PArEK?Y#$I3?wlVUhq9otel6;%B|FCKiXfkk(Vy`n2c9Jv6^?s<+_ zr;>&wAA7XUU{te(!vHdddP48)&l%#Uv#=FJ{d=(oM(7WE5E~wD-Z9ji9-G9BLaA;@ zF8g5!@ao`13SE?!7G?u(Dr=TxE|f|ne2H$s`10iZM7;^aiXI2UoL>SBlVGZUN*rnC zL_OF7O{p(xC7lKgkj`R%Ch@~uetL>Z^YiqkkFT$l;s^ru;wp{#F5w^~v&#p{yG4-Q zH9$Q_GW*~|#>Ui)TcWc7f}Y)h0f;E1hgR$1bHp*s7v!s)j>Ppwone(@;pX{qeVHvw z#d`np%;N}8G()ZV4~kC=9e!QGTKH7YqkM>Kj_d(r#pHQ1HA%c;BJ?Y;HCv)+&etn~ zC+LuYR6@*1mSxH4+9}1ob{3mJ4JM^R(4+XHEQ)W3DOc)r1W}3GFzw2utOFX6C$3Q5 zXVjsOKIz?R2a!Q6l2r!Wu83n@N-CQ%oJhaC9J!c{N@wZ8Iavu`jzDHQ+2$53tglJ(T9ho zB%g?Hgl#W~@YR$I?IJAiFdGyKMK@Lzt`lm=B1GGy=PJ$Mqe3g(kp+LQIKNht2jYC;I93y^SV0Re?Zm&C@~lTyx3vM zf)KPnIk!^=kq|+ZZQy4cY*L`sVOzddizkXUMcMG(%oD>1x))EjAaQ*mo)(2f#L3p>C?sFIR9BHb4QM%PaB7)iI^U}nWxaXy0FK=XP|!A|WcR=Q6*hnZvcsBFW&mD) z)5BQ%LNP7_>yw2f;5~AP{q@SY)`QSH>M=vJk-D1HgnAodA@@+3-07$HOe?#@Hr5kX z6u_lb+bw4#`Fr91?RzLqv`b|m_5dCJ6QgPL4H$Qxa6uN9c9klHrPnt zsmJF)UUD>rZ**W?wXC^>uzii7cCN}hsSz1YdWRC*S$|js-uYz`{42Q=<-#{uUq4$8s?A-m$DRIOm|Yj~0^);f`d+67M~t9Q2356g0<& zNtV4kNitx#Ru=RZRRw|Qqo5ng!_3D|0N=e-iQ_R6gqfHO$kqm(&fHzS8PR$U*(Rfo zCmZsYa4y_q$14ee7O~=IJ{K6tKx_pix2T4)KR?y7w7oteEr00n{oLvJ^|Sg2iwi^) z8NWn%sL#0ZdbI7WUMC|UEqF4`kp5Vsd1@8^C3uFS%|GhAKv16jsW=V?y0HLKb@{mQ zlsRlJkj8yszRemZ?h<~m2v;Ch7Mw3EAwirWec2B=zmqwj0+JyJt7cY~sjrK~-W;pq zXu-P`3uo{J%-{KiaCN>ZoSjVo>LT_l3U+fCR}@2WKX_)tNUQ3@e>gH8G}SQ4Tx)WQ zlF|P}@$+s3Vkq>?Lt4ARYr{9EHKqiBU`v15%ZCbpmsyGD8xz*NGj%8NULvCOEaKgY#oCxm9T(Y{4Xf>(R;pyctcwJ*p1(k z*SOxH13IAmW)AdxaVKvb^If3 znZL`T&|qB>dUUAXPd02r#1rjp?@R_k3Q_S6q~+s39FxzU1UL?TQ|Uz)@>t@5w)jOQ z*~8-?20qge4XsfBhaMqjcuPF9P;Uzo=CWSQD=thavsN6vznG(O#nu5b&zgKHQgKhc zaJ-S;q#>dH?o%#i^jqp4YF%C5v$0F4WV{7oi9s?X*A>{<|2!=KyDg8&{`Q}ic7}&I z|J=gA_#qPXpEUnf`0peCtL1-|D|ExSaOAY9LwPg4R2Owx52GH0zI$vNgxa~gW90;Y zFm4m=J`Ul{@bv`#li2_F*KH5;x=7n^=Z|<(87@J%TPz|4DdkZ$&P!wO?TLc7c_71s ztvtnK(cQkrI)3;Iw_@rPndFJ?QQ^zPz!IytuX#I3W|B=D2EJe?f3NN4Qo!6~bNU)v zpeSJZ4&_q8s(d`0A|x`UXY{R>t!B*7btXZ8DGx-&>$GqcK0VpngYvualy^CT!N`?6hY@YLZxE25V+=~&?xYFe&+%!CHhC(6oDBMJo*PXa*O-f z2$DDRixI=~B_>~EUxu9Xdn0F8fKlh*_(_!Ea3#P`IGtbL60Al$|X1@6W0+Zi5 z*jlzl+zaV;*;WN4DtlrL&mJHXRQtTXf+kF`O$8J!>sswTp^~Ny+^|}(`-=f{-XkNM zviC+(X6H(P0hyM>Xi!cPaA&uotz`^o*GLrqi}%aOToYePFPW$T*1?o{aKS#H_KP>s z_e4VSKPSKep|>n%Y!Ep!6EGhhigkVcQCh)gjQW{yHIg!V<+a*(?mekrydKI{aTYXj zf>Jr1CDwJRaIVDRhSkv-k;J05rt&K$z^}{#;8Xb(d_E2kwLFFR6TEXKarmzLgF}2( zl|oCN-@Khm2AFk8Ks65eFQAU*OPcI4K2-+(6q~O0A9N!Sx{l<#_#R)&MIUmU* z31Hj?)J+v9WmK2Qy8+%(%m_9 z1wF0>%LlNx>{jZXS-$khv8Jj=9l^iE;q)ptk3<@t&H-{tFwTYl8sJN6qOHFq1+m(? zaORK(2jI#-qd|TWQ~Bsmo3DrMrLjSY+{74q@@TJ^bZ0zKWy)-JY}MKs1K~EZ|(PH7JK4%Y9WU1bU8U+C-{y2 z^{5t2(*nlp_nb$8?Fo87$>ZMHGF2Xdm=u;90xjEoRji$-I12#J95c=@jhs-me4^~| z!;&+*-!Dk62aA!rr;A!0q4J#OVtNF0Bl@t|-Ny-!v(!$$5iJDv%r*oJ)~e|*;Ld>_7T2>A#O?-|_p%(BdYkmuFp*|f4`Ys_V z=j|~EbMq0I+V}it&!+auj{ymoKg!#W10RM_j4X=7n}0V_RUSRVuGsabf~A=&(nZU>4BUzBLs@PWnxoZ6 z3lEj7B)|?Q0YTR(TL2yoE(Xkl3832)um5A5IyXRVKwE8OD_zx*m4jE>$witSrk2iG z5&MT*{O_a9NX-CJ^xw*e9?4I0=Cv;aSk+;r(h(0IsigpZ_qxw?j zFHFbBnH>_0vNZL7FPauDZ(IJ`!Gq~T^T;y-+D8N-r;RV96oi|H~1VwPK4A}|8@KA0svW{VX0 z_&~?vj7Y4|4el&=ZEXg4DRXpsKK^Z)w0{FVu1^PB6tVA++)^yd&wYBRgL}equbfy(WP9gW9@La*~k5(dnDz!hKv6=rm#Y&w!9OXp3SmxIs2D{w+W8y10B-`~;z)(i} zHtLZ9wwd&lVCg_d_ZR*CJ%jQd8b2bZTtyqU5FVq#fcdKQ%g7#wwdd&3fS4z?;WUbi zeQ$?_NVlE1BwQeoBQ<4m^(nmN;qSFnz}w z*GjsBndU(nNs)jUtnaxAF-h6oFio$dD_cm?BeTHNUiS2Y+hJIOTW=R!*vnc(Rgkzfw za$)j8f}Ayg9=qO#| zzg14Z86v4b1)huEPzv&CEsn|cuexJxU>^~^=^|gTA;_Kyq3Sa2InQd-?}aFWD=L## zaO{Y6S6;sy1lvu!qY(C2D^xlI`NY=WVZVdM<04;^BD+8Ibr^+}Ok#(++r)L~_fm2E zs-07MN^JI0#Z4aqU$=11UJgqLK846QR2SfmeBGq3#+6fLd`+Vte<(Xvb=!!lV)N-a zU!hAfs<0qOShTB@*(jYR7HGDj01k2TfP$x%#DyH{7%z?kEs8-7+~ZJNohSHA^@Vf5 z3A;qOF;1>jrqLCmNas=>795K;wx^&Coz~S{)@G&Nmmt1d?|^dm`T2RH5yZ5&vq#8C ze96z5)w~3ncw>6m4xS`BvyhU7UU>@q$HUE%7^+`7Lt}NTXJc2K>RoJRRwL}0S6gsc zk64!j;=W&Qc5e8VsM52%80jcNFn&t2cNe3g^Hs6M)R_9>eCw)(No$e^-NRuD?rL2& z9Ui)i=f)^NQ=R1l3{jTJr#4J^XQ*!t*Dr1d`@(hwgDn7Wuj>Xg>{2fCf3SJQ{Skzv z=7SU(b%GyI3;^gL@L>Xy<*kUb688vZ9TRDVCkBd3wV&VdeS14MY}N&35!ktCC0e-f z7l$&&f2#nlf_?cA`bkxfu|zL0WGWOYx(t}s<@uw<=G0{WW0 zF--r6Ju95@CkEIy;XpX-0jYChfbo}e{Q7wL&=hCES+s_lC`<%kp;&dnC1vT;TKrC% z0qM~NCZlcUD0(03h{#27)pv<@tqA5HkMg9Sx zB3-ZL083F<$}#}ZTWw=gov#ucy!*|)$^0ZahV}#0XvdLnp&iNgCCXHB0nRAB%n?ax z=}Z^dB5dF)b2<3*BnxQwjofn8J1gV!ZcoH{i57U!E}>eWKA9p5+v!1dq+S*;EF~o= zkO%?5NWlr5j#W;J-^U&FR^|DI)L7mdm*JfqX?<~3plcw!` z-ec~$>N!kC*tIDj_bd+|-EAZl&T|1uwuz%#Y9x(;VkXu)uq0tX zX=8G*iwvy60`Mw$hJQp8qsW#(;%L?V zM>KL5NxnI4}Clw>_hBY2fccHEso)nzgeoQs#CK28qlKr8usNk9j4R@J;kbu zAWarode031SR60}n0a$4=+g-13 ze|-S!b~4&!Z$fGY`VlE5nOFx$G-eS$`;!;x;qXUPY4!2yGe&rDFl=oq@Xq%*Cg~HF6 zXhC8#3q1JBiD;G0b6S#J116HO2EY}ppiEd}svqhBk-ZV9B2)r<&7=MvJ!{$M22ADG zN>FO?_I;og8<++0)%#9Wm(y8wul-ETGF=Y9$^Ko69-1jmip0&9hngqCRNnmXlmS4D zFbzWWiUtcTFq)d+@d*C8lM;Qfd|TxIZNHS7&lk)WOT+$yNSA&-`Xum4oN}Msk{byk zS#1H`N@n5({X_!EUepEymLnAJRhJbRl8kj13NP09CaYR90Qf9NlzrVfM_Cph zS*GF7jJUO+$H9{l`@B-<`)Lt!5)I28rU#&u#rRj49KCdM!vRI$gQZmq+A32bvp>=) zJU}DZ7{O8vNy6sPMA=&pQOtvJPNM2!neyh>FYp$UAC#7tyOBfK`5w>hFABoSIy#tTvXeL|Y)rNcyR9=Pu zF2?b?BUhjS;lU+QEO^LPQjRBPjPJSir8qWM;qmFYKEZ9>IK!z|+KnQ)bKc#%i17b& zxwiVhznbyie{19a`AWz0iOS$nr9eI$_{j>1!TTo(Sq>D(3aZfN%@?)v8@v!kU<>4Y=?pKd%rDwSUUD^|R z_ciENpvgtmle8k*lT)dwSJ7XKizp$v>q`8^ReEAw#xH|_@&cy`s#xDJpV1R!e;agT zEQ}FIX=5T3PqXhP$`j{kjx;dpomK`FD-6*xL%d@N+(1I)N5&0ckf*jlc0$%h$A?uj zfbKO3&Fp4dF?VqP=CYl)o7Py}XfExY6m4*-%9u%b_-8o_r9ju6Gno%}plhkut+ ziD&O-oBvp~H@H^l&kwbf?iuqKO+J;y)BE%2R~S{*1P-Knm+mQ?XO0ZN z+2;L=lut}tq;{j>RP)?ZiKW5)Gan-qT0Y*e$WuvaeXdXJfK5`CC!9N<I%Nd^iMtXRCFh2*j4$C>Nx$_`hGL+&Nu{zrTJ78@wBD<@*<|8K5#Cn51^h{pMb! Nte_!ZCTkY-zW}k&7v%r| literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph/index.html b/en/chapter_graph/graph/index.html new file mode 100644 index 000000000..8e1aacf40 --- /dev/null +++ b/en/chapter_graph/graph/index.html @@ -0,0 +1,2490 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 9.1 Graph - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    9.1   Graph

    +

    A "graph" is a type of nonlinear data structure, consisting of "vertices" and "edges". A graph \(G\) can be abstractly represented as a collection of a set of vertices \(V\) and a set of edges \(E\). The following example shows a graph containing 5 vertices and 7 edges.

    +
    \[ +\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} +\]
    +

    If vertices are viewed as nodes and edges as references (pointers) connecting the nodes, graphs can be seen as a data structure that extends from linked lists. As shown below, compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) are more complex due to their higher degree of freedom.

    +

    Relationship between linked lists, trees, and graphs

    +

    Figure 9-1   Relationship between linked lists, trees, and graphs

    + +

    9.1.1   Common types of graphs

    +

    Based on whether edges have direction, graphs can be divided into "undirected graphs" and "directed graphs", as shown below.

    +
      +
    • In undirected graphs, edges represent a "bidirectional" connection between two vertices, for example, the "friendship" in WeChat or QQ.
      • +
    • In directed graphs, edges have directionality, that is, the edges \(A \rightarrow B\) and \(A \leftarrow B\) are independent of each other, for example, the "follow" and "be followed" relationship on Weibo or TikTok.
      • +
    +

    Directed and undirected graphs

    +

    Figure 9-2   Directed and undirected graphs

    + +

    Based on whether all vertices are connected, graphs can be divided into "connected graphs" and "disconnected graphs", as shown below.

    +
      +
    • For connected graphs, it is possible to reach any other vertex starting from a certain vertex.
      • +
    • For disconnected graphs, there is at least one vertex that cannot be reached from a certain starting vertex.
      • +
    +

    Connected and disconnected graphs

    +

    Figure 9-3   Connected and disconnected graphs

    + +

    We can also add a "weight" variable to edges, resulting in "weighted graphs" as shown below. For example, in mobile games like "Honor of Kings", the system calculates the "closeness" between players based on shared gaming time, and this closeness network can be represented with a weighted graph.

    +

    Weighted and unweighted graphs

    +

    Figure 9-4   Weighted and unweighted graphs

    + +

    Graph data structures include the following commonly used terms.

    +
      +
    • "Adjacency": When there is an edge connecting two vertices, these two vertices are said to be "adjacent". In the above figure, the adjacent vertices of vertex 1 are vertices 2, 3, and 5.
      • +
    • "Path": The sequence of edges passed from vertex A to vertex B is called a "path" from A to B. In the above figure, the edge sequence 1-5-2-4 is a path from vertex 1 to vertex 4.
      • +
    • "Degree": The number of edges a vertex has. For directed graphs, "in-degree" refers to how many edges point to the vertex, and "out-degree" refers to how many edges point out from the vertex.
      • +
    +

    9.1.2   Representation of graphs

    +

    Common representations of graphs include "adjacency matrices" and "adjacency lists". The following examples use undirected graphs.

    +

    1.   Adjacency matrix

    +

    Let the number of vertices in the graph be \(n\), the "adjacency matrix" uses an \(n \times n\) matrix to represent the graph, where each row (column) represents a vertex, and the matrix elements represent edges, with \(1\) or \(0\) indicating whether there is an edge between two vertices.

    +

    As shown below, let the adjacency matrix be \(M\), and the list of vertices be \(V\), then the matrix element \(M[i, j] = 1\) indicates there is an edge between vertex \(V[i]\) and vertex \(V[j]\), conversely \(M[i, j] = 0\) indicates there is no edge between the two vertices.

    +

    Representation of a graph with an adjacency matrix

    +

    Figure 9-5   Representation of a graph with an adjacency matrix

    + +

    Adjacency matrices have the following characteristics.

    +
      +
    • A vertex cannot be connected to itself, so the elements on the main diagonal of the adjacency matrix are meaningless.
      • +
    • For undirected graphs, edges in both directions are equivalent, thus the adjacency matrix is symmetric about the main diagonal.
      • +
    • By replacing the elements of the adjacency matrix from \(1\) and \(0\) to weights, it can represent weighted graphs.
      • +
    +

    When representing graphs with adjacency matrices, it is possible to directly access matrix elements to obtain edges, thus operations of addition, deletion, lookup, and modification are very efficient, all with a time complexity of \(O(1)\). However, the space complexity of the matrix is \(O(n^2)\), which consumes more memory.

    +

    2.   Adjacency list

    +

    The "adjacency list" uses \(n\) linked lists to represent the graph, with each linked list node representing a vertex. The \(i\)-th linked list corresponds to vertex \(i\) and contains all adjacent vertices (vertices connected to that vertex). The Figure 9-6 shows an example of a graph stored using an adjacency list.

    +

    Representation of a graph with an adjacency list

    +

    Figure 9-6   Representation of a graph with an adjacency list

    + +

    The adjacency list only stores actual edges, and the total number of edges is often much less than \(n^2\), making it more space-efficient. However, finding edges in the adjacency list requires traversing the linked list, so its time efficiency is not as good as that of the adjacency matrix.

    +

    Observing the above figure, the structure of the adjacency list is very similar to the "chaining" in hash tables, hence we can use similar methods to optimize efficiency. For example, when the linked list is long, it can be transformed into an AVL tree or red-black tree, thus optimizing the time efficiency from \(O(n)\) to \(O(\log n)\); the linked list can also be transformed into a hash table, thus reducing the time complexity to \(O(1)\).

    +

    9.1.3   Common applications of graphs

    +

    As shown in the Table 9-1 , many real-world systems can be modeled with graphs, and corresponding problems can be reduced to graph computing problems.

    +

    Table 9-1   Common graphs in real life

    + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    VerticesEdgesGraph Computing Problem
    Social NetworksUsersFriendshipsPotential Friend Recommendations
    Subway LinesStationsConnectivity Between StationsShortest Route Recommendations
    Solar SystemCelestial BodiesGravitational Forces Between Celestial BodiesPlanetary Orbit Calculations
    +
    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_graph/graph_operations.assets/adjacency_list_step1_initialization.png b/en/chapter_graph/graph_operations.assets/adjacency_list_step1_initialization.png new file mode 100644 index 0000000000000000000000000000000000000000..c2b3af5714a6bf41fdef5baba10a10a857c0351f GIT binary patch literal 19659 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 wpU9o8AO#NttXret#$^Po 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_operations.assets/adjacency_list_step5_remove_vertex.png b/en/chapter_graph/graph_operations.assets/adjacency_list_step5_remove_vertex.png new file mode 100644 index 0000000000000000000000000000000000000000..32809ccefbc820019480443490e18d184e89eac1 GIT binary patch literal 18618 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

    H9j{?gu{ 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̫m*=u_XRPT!ZiI65Ne-rVaL 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_operations.assets/adjacency_matrix_step3_remove_edge.png b/en/chapter_graph/graph_operations.assets/adjacency_matrix_step3_remove_edge.png new file mode 100644 index 0000000000000000000000000000000000000000..3649321b629d362da87ab87c7da7b1b32531a940 GIT binary patch literal 18885 zcmbTdWmr^E8!o)}1Ve`)p_Cv|D*pM|+2Z2jX?B2|oZR&E^u@wxM@PrS#f7o4acXMn_wU~a z1_oqgWLjEUl$Dh?XU7i?4)*r;-n@CUzP{em)1#`Y8WR&UF)`up?%vqgn4FwEJ3HIo z-@jRzW@%};va+(YwDkJ*YX=91?CfkUEv>%3zO=5??d|PPpFUL%Rc2&lw6(Rx#l@AD zmj35YHDgWH#Y|d2jkjfO-)U!C#otdE2COpmwYb{YkGAQZaDpSdVF>K zv?@8VE8*zPlau1N$MFu^N83ZoL(MbI7r!RY`|GyMS(bN}&PQ4|b#9(~@V=NGI{(p| z(f8pbFMQjU?{eqwSz}IE&Z`|anajhyv+lCQ!i3%9-Iv8LXJ4APy>hJRsd$(Bu07!; zVTZsm04TRSRFr${GrisxeBHwUly#9$l@I%u{l7~VUTdUC3u@dPHZraLu;f?sSD!wQ zRS9^qZ=L*X1pn8Z$B|?yQ$|k}i%Q>qEb!gZbq{>@wlJXQ$OwLRd&-Q7a-mdq+{8cY z@O^pzt>fVM4}Q*$x85v@UHW;DC`U)eednI|yDj7FQz()0de!5#4Vz9%h`#1bgSuds zBVpHV{FZ0&taK0Er$3FWaIe4@Z6s+A!_719(FlfIoh90wJme#+oJU(zjPY)XsW-o> zDVFxK{Udxa*S34QdG*8ymmer%ghdFv8DKB_d!X>RIoRv>Ve0H=OD3f}AyBCm+*?`3 zhh)_jk3Lt*1j7tH1ZqTE8sk_COLJe5!ZAk0=tUZf#2b@xm#G=xDUrwezCzYdUR!VD zup>VP4T3v3P-ZY=5FSpfQ3#`(+2xIO>`S};=$gheuYax=X|SrX-(^{Yo`WaL?2Tt0 z|Iw2bRB*F{H#p(D?A+^(ppf|QS?}ip#JNMM5z(XSXE(Bt_nw<1!ghBaEjS+htRl4} zO&+=2Ax!>?;LTiR(8u`yUCwVLvN^mqEiU+oi@(5k-0T`v3M?1+2=U`s9Z5dM~JaeH`JlNnMTLOhLJ zReMH0EtpKe*YVtyqJo^tLVaEqw%cF1xmjs= z1Q{0FNa5RUbeK;Q9opc`=oY@@oE z6@|38C^PQ_BIjwRi5GNpW^ff@xNpWC@8oP)d7j0_dXbrAfSQXLVJRknBi&9m#K6fZ z3zhaUTVxp1&zK_V8=Z*x>gLWpq@c}r&Ml*VG>P)~&1;)*DRXMu0s2q69ayuFP`8hY zex;_3HBau+V`znE-W`G76@R4EJFi@zI#-cGj-?vXFPL5$aQKN% zEqRfvxQ<2wEjn-Z|HQshaxyY|iQD!k0H~eYe?&g=t${gjMvf>!mLMxz4c+zlXX2Is z_;|o{_^_kf0FYS~yCNRo(kG-!w)NT@^#>#~57Xg^DR%X6g0|I1fb+s0#cfau?dlD5 z%D<4NL>KujN@^%3WsVhZZR4!(Fty_h@5-b!f`T$XlbjZPGW+M`X;j%<8td(3pbr}1 ze(vt;RZS?$kdY{Wem?N(GA?=pE+(V4KYXUwrj_Fu2b4_RPG!x}@l&`bL6{Xzl4Zv( zs0u8s$bykUgOU=N{1D6gNX7tS*7oMZ7gbvOw}4iwmf2p^@NR@4;V8BYKK3G52=&U5XbSm5Tb!t?Ob!UY4vI zEM<%EWW?upyuqH|)3zLfhZ^vz)Oqyr+*v5pyhH`Ru~U_eee)p7+mWSLHT!SFdkZ7C zCkh0g0HQLV96J>hYLWeTitXBAZ7#8%@L zrv0gf{x+~kc|F3*B5m$LZQmI2_^KK^x1#*CPt>1<64O4l;vJFa2CFw#9PRp`=t0V^ zk6j0?OEIasnAcA2X2JEBG_M!Fsa2}@%zUeQg`?lqchewZVSVmOmE4uKXXnRwv3|AQ zZGHW@X_X3IYx7=#k9oRdWtNoVdiS5g<+Q|4oy-GqL$k7E8-`Ydl4fS+Ob4iU1G5%u zYqu6M{GCK~%lN@24YMe`EPg4CkFQ%{t2gc6JV)_$Jt!tT|Iq^^$=r7iKKjD|ueu<2 zf*v$3{~_T_!kAy#NYq+vbRWyBGr%9)cl3ejFVyJ`i7ftn#V#B!v@=x7{MiEdex7}1 zgW8yDV5^V5=QYWn0%1>%k-wfCH%K!Z-n&hOIch8I5>5Hcfay5|ehZ$|;Z9u&|1Q#; zq?5c5c@{c2E6SMUVl+(Z6tcPpB;44SfpSy7MJ=J96dBIr{Svq+pV8QorQI(fiZ)C6 zAmrF7;GAmB87>0347uk?ks`N`2j0I3Ct2HR#h=ZH+A`RgGUVixA@g+vsH7RoN@WEd zcNfXC-FNM|a2tPp>2L+;p|E&M2^q+cC`&uU3^nYFu6TCK2Qfjgi@e`=w7m!Zszb5)`m0wAPa#Xe)WphKs~>#;dwee zsr_3rX)6&PkzQq-;q+q82Wc^D0^CbWgddk!8C@}DY2SYK#i&^|24IVhrENT&ocIP; zk8dL0tG~?_`?0O8`RMk+Zb@`n)B~)qa)8^tB3Au3i?cxV^k=|S?7Jx`%>coTS)9wN zeb&*3msYrcym~Z-0!Vb!qV^5>R4(*?*y(CzqzUWuBv-iNV1=VRfIK z9~gE8Mss)%O4BIA-`o5V=V#yFecAHwi|8)Pe?<_g$JEuBYXBzP#E(Ex`uPTw6rEiI zWXzc%ui7PRSVYWR;hm+8U-nh9nPE=+;akYCCzuoys*K)?)(#-2?-&q0{86P{a5OvN z$J0=!+2bqqDgI^*#7->#;twtx1F*dO(EDhrO50wCGzM}*(LM-e&YEl;@a>P^*le`> zJoYqpT??H|30(Oi)(_u~kgpGlPqn1!sW{@-Baj2BMri99FUCut&UtQm>TctiixK-l z+J%IkCu3MJ8^=v!q8m!F5%HRTR?2R z*p0V7)oQ-yFqLKV&rrgkVzHUHwNL?#+&_uRxZvbmVyG?O7AD(hdklg&G<@t`aY3*d z#vonM}7wifNd? z?9ZOMq<96u!qpmOS~EQ#DgI0QJ?e8GSxN7MfPd)n&P{e5B$f7EN=kMvE=166IRX+! zHZGql&OBVBh;Np^1l%M3m)lpLdzp_$xfbh78|ZP+RK9RMvR*lIfY9F z{@+(+;_&nFZ#|x^N#$~0}hIBE`fLAJCap0(D!hMLUs(;?Xh?jdPtjYb2h9xT~s5kL0 z`-vq*X)E$X$0xqwM~W0Y4l5e7*I_iIUDf&Q#<~H<)4`L!#}}BeXYYxCQZGy0++l-r zGOtQJ`s?5DcX@S1S<`e*rA({=Kf62mA>o3xcc&pcX^7#!WW-CqM}@#z>2!v8l>#Fm zn!QQec~E7N#)n^Vd1d#U&y5fpn?e8V?=6`oCE$X<=UwIZaasw-HA!+kJ)UX=vFZ~^dg_VF! z1V6QQ?LVEafa?mI{Ub|SoY8Lx#M7o|viM(#=7TFn?IY9?N2t@bA&d1}=;dKO_HZ=u z=B?=Nck5^4qZ3Aaw8Hu__6{gAsz>Iw(s{-}^ov%UBRm)5@6<7=B*30(@p0Rzl{D&f z5Ns-vOT-l4L+P4HZ3wKCzR z#0-;x7p?`xT}{2qjCtVCvJ$$^>+-LQ`9tS3=ncdTqz%v#-&NA8jq6dGyAAPI?p!MQ zjVpcBdnF0Gn54D4hSfRMmo2%~zwAV!!-u@B&hAC<|NgLhKsCSP`mmeY>J9(@{1_1R zTARcHNO3GJ?%oO!xOFzvL25ocd*DR$zxdOOF?ZKrR7Xk_HUh9peM=3bx_*`hNX-a= zFsZ}MGx119eC)9m(b*eZ4kiw=xbm(%{t*LBE;7IFkXx$j+!BW+AIm!>4uhs@32se; zwNyJIFEU3uB=!!Iw$|rA#KC*1t!UBR)V~0MZfaC4f43O)ro1ou`f^&;zwE=P|7~`l z`oUca;&6B{T8tL|6()%3j&N4SP$pcU6$=P>Gd)hk&&EAgzN;e5l4|lB_|Lx59j?e=fkdM@7u&VD@wJcD{tmDNFFH38jL-DbZ`LpMZeq z3p^^(K&#rx*F^hrPne!an|}ip0;yxGXV*(Oy)C=J^po?M6>MW|H>l>pG9!g3lcf

    KAL-Q+pd(gnEPD*xB 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 x^n?}s-^*Sduy{|~r#UcCSS literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_operations.assets/adjacency_matrix_step4_add_vertex.png b/en/chapter_graph/graph_operations.assets/adjacency_matrix_step4_add_vertex.png new file mode 100644 index 0000000000000000000000000000000000000000..87d03db8285b238be47d5a9868b8ee87adb6de16 GIT binary patch literal 22167 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + 9.2 Basic Graph Operations - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

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

    9.2   Basic operations on graphs

    +

    The basic operations on graphs can be divided into operations on "edges" and operations on "vertices". Under the two representation methods of "adjacency matrix" and "adjacency list", the implementation methods are different.

    +

    9.2.1   Implementation based on adjacency matrix

    +

    Given an undirected graph with \(n\) vertices, the various operations are implemented as shown in the Figure 9-7 .

    +
      +
    • Adding or removing an edge: Directly modify the specified edge in the adjacency matrix, using \(O(1)\) time. Since it is an undirected graph, it is necessary to update the edges in both directions simultaneously.
      • +
    • Adding a vertex: Add a row and a column at the end of the adjacency matrix and fill them all with \(0\)s, using \(O(n)\) time.
      • +
    • Removing a vertex: Delete a row and a column in the adjacency matrix. The worst case is when the first row and column are removed, requiring \((n-1)^2\) elements to be "moved up and to the left", thus using \(O(n^2)\) time.
      • +
    • Initialization: Pass in \(n\) vertices, initialize a vertex list vertices of length \(n\), using \(O(n)\) time; initialize an \(n \times n\) size adjacency matrix adjMat, using \(O(n^2)\) time.
      • +
    +
    +
    +
    +

    Initialization, adding and removing edges, adding and removing vertices in adjacency matrix

    +
    +
    +

    adjacency_matrix_add_edge

    +
    +
    +

    adjacency_matrix_remove_edge

    +
    +
    +

    adjacency_matrix_add_vertex

    +
    +
    +

    adjacency_matrix_remove_vertex

    +
    +
    +
    +

    Figure 9-7   Initialization, adding and removing edges, adding and removing vertices in adjacency matrix

    + +

    Below is the implementation code for graphs represented using an adjacency matrix:

    +
    +
    +
    +
    graph_adjacency_matrix.py
    class GraphAdjMat:
+    """基于邻接矩阵实现的无向图类"""
+
+    def __init__(self, vertices: list[int], edges: list[list[int]]):
+        """构造方法"""
+        # 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+        self.vertices: list[int] = []
+        # 邻接矩阵，行列索引对应“顶点索引”
+        self.adj_mat: list[list[int]] = []
+        # 添加顶点
+        for val in vertices:
+            self.add_vertex(val)
+        # 添加边
+        # 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        for e in edges:
+            self.add_edge(e[0], e[1])
+
+    def size(self) -> int:
+        """获取顶点数量"""
+        return len(self.vertices)
+
+    def add_vertex(self, val: int):
+        """添加顶点"""
+        n = self.size()
+        # 向顶点列表中添加新顶点的值
+        self.vertices.append(val)
+        # 在邻接矩阵中添加一行
+        new_row = [0] * n
+        self.adj_mat.append(new_row)
+        # 在邻接矩阵中添加一列
+        for row in self.adj_mat:
+            row.append(0)
+
+    def remove_vertex(self, index: int):
+        """删除顶点"""
+        if index >= self.size():
+            raise IndexError()
+        # 在顶点列表中移除索引 index 的顶点
+        self.vertices.pop(index)
+        # 在邻接矩阵中删除索引 index 的行
+        self.adj_mat.pop(index)
+        # 在邻接矩阵中删除索引 index 的列
+        for row in self.adj_mat:
+            row.pop(index)
+
+    def add_edge(self, i: int, j: int):
+        """添加边"""
+        # 参数 i, j 对应 vertices 元素索引
+        # 索引越界与相等处理
+        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
+            raise IndexError()
+        # 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+        self.adj_mat[i][j] = 1
+        self.adj_mat[j][i] = 1
+
+    def remove_edge(self, i: int, j: int):
+        """删除边"""
+        # 参数 i, j 对应 vertices 元素索引
+        # 索引越界与相等处理
+        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:
+            raise IndexError()
+        self.adj_mat[i][j] = 0
+        self.adj_mat[j][i] = 0
+
+    def print(self):
+        """打印邻接矩阵"""
+        print("顶点列表 =", self.vertices)
+        print("邻接矩阵 =")
+        print_matrix(self.adj_mat)
+
    +
    +
    +
    graph_adjacency_matrix.cpp
    /* 基于邻接矩阵实现的无向图类 */
+class GraphAdjMat {
+    vector<int> vertices;       // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    vector<vector<int>> adjMat; // 邻接矩阵，行列索引对应“顶点索引”
+
+  public:
+    /* 构造方法 */
+    GraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {
+        // 添加顶点
+        for (int val : vertices) {
+            addVertex(val);
+        }
+        // 添加边
+        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        for (const vector<int> &edge : edges) {
+            addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    int size() const {
+        return vertices.size();
+    }
+
+    /* 添加顶点 */
+    void addVertex(int val) {
+        int n = size();
+        // 向顶点列表中添加新顶点的值
+        vertices.push_back(val);
+        // 在邻接矩阵中添加一行
+        adjMat.emplace_back(vector<int>(n, 0));
+        // 在邻接矩阵中添加一列
+        for (vector<int> &row : adjMat) {
+            row.push_back(0);
+        }
+    }
+
+    /* 删除顶点 */
+    void removeVertex(int index) {
+        if (index >= size()) {
+            throw out_of_range("顶点不存在");
+        }
+        // 在顶点列表中移除索引 index 的顶点
+        vertices.erase(vertices.begin() + index);
+        // 在邻接矩阵中删除索引 index 的行
+        adjMat.erase(adjMat.begin() + index);
+        // 在邻接矩阵中删除索引 index 的列
+        for (vector<int> &row : adjMat) {
+            row.erase(row.begin() + index);
+        }
+    }
+
+    /* 添加边 */
+    // 参数 i, j 对应 vertices 元素索引
+    void addEdge(int i, int j) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
+            throw out_of_range("顶点不存在");
+        }
+        // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+        adjMat[i][j] = 1;
+        adjMat[j][i] = 1;
+    }
+
+    /* 删除边 */
+    // 参数 i, j 对应 vertices 元素索引
+    void removeEdge(int i, int j) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
+            throw out_of_range("顶点不存在");
+        }
+        adjMat[i][j] = 0;
+        adjMat[j][i] = 0;
+    }
+
+    /* 打印邻接矩阵 */
+    void print() {
+        cout << "顶点列表 = ";
+        printVector(vertices);
+        cout << "邻接矩阵 =" << endl;
+        printVectorMatrix(adjMat);
+    }
+};
+
    +
    +
    +
    graph_adjacency_matrix.java
    /* 基于邻接矩阵实现的无向图类 */
+class GraphAdjMat {
+    List<Integer> vertices; // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    List<List<Integer>> adjMat; // 邻接矩阵，行列索引对应“顶点索引”
+
+    /* 构造方法 */
+    public GraphAdjMat(int[] vertices, int[][] edges) {
+        this.vertices = new ArrayList<>();
+        this.adjMat = new ArrayList<>();
+        // 添加顶点
+        for (int val : vertices) {
+            addVertex(val);
+        }
+        // 添加边
+        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        for (int[] e : edges) {
+            addEdge(e[0], e[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    public int size() {
+        return vertices.size();
+    }
+
+    /* 添加顶点 */
+    public void addVertex(int val) {
+        int n = size();
+        // 向顶点列表中添加新顶点的值
+        vertices.add(val);
+        // 在邻接矩阵中添加一行
+        List<Integer> newRow = new ArrayList<>(n);
+        for (int j = 0; j < n; j++) {
+            newRow.add(0);
+        }
+        adjMat.add(newRow);
+        // 在邻接矩阵中添加一列
+        for (List<Integer> row : adjMat) {
+            row.add(0);
+        }
+    }
+
+    /* 删除顶点 */
+    public void removeVertex(int index) {
+        if (index >= size())
+            throw new IndexOutOfBoundsException();
+        // 在顶点列表中移除索引 index 的顶点
+        vertices.remove(index);
+        // 在邻接矩阵中删除索引 index 的行
+        adjMat.remove(index);
+        // 在邻接矩阵中删除索引 index 的列
+        for (List<Integer> row : adjMat) {
+            row.remove(index);
+        }
+    }
+
+    /* 添加边 */
+    // 参数 i, j 对应 vertices 元素索引
+    public void addEdge(int i, int j) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
+            throw new IndexOutOfBoundsException();
+        // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+        adjMat.get(i).set(j, 1);
+        adjMat.get(j).set(i, 1);
+    }
+
+    /* 删除边 */
+    // 参数 i, j 对应 vertices 元素索引
+    public void removeEdge(int i, int j) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)
+            throw new IndexOutOfBoundsException();
+        adjMat.get(i).set(j, 0);
+        adjMat.get(j).set(i, 0);
+    }
+
+    /* 打印邻接矩阵 */
+    public void print() {
+        System.out.print("顶点列表 = ");
+        System.out.println(vertices);
+        System.out.println("邻接矩阵 =");
+        PrintUtil.printMatrix(adjMat);
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.cs
    /* 基于邻接矩阵实现的无向图类 */
+class GraphAdjMat {
+    List<int> vertices;     // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    List<List<int>> adjMat; // 邻接矩阵，行列索引对应“顶点索引”
+
+    /* 构造函数 */
+    public GraphAdjMat(int[] vertices, int[][] edges) {
+        this.vertices = [];
+        this.adjMat = [];
+        // 添加顶点
+        foreach (int val in vertices) {
+            AddVertex(val);
+        }
+        // 添加边
+        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        foreach (int[] e in edges) {
+            AddEdge(e[0], e[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    int Size() {
+        return vertices.Count;
+    }
+
+    /* 添加顶点 */
+    public void AddVertex(int val) {
+        int n = Size();
+        // 向顶点列表中添加新顶点的值
+        vertices.Add(val);
+        // 在邻接矩阵中添加一行
+        List<int> newRow = new(n);
+        for (int j = 0; j < n; j++) {
+            newRow.Add(0);
+        }
+        adjMat.Add(newRow);
+        // 在邻接矩阵中添加一列
+        foreach (List<int> row in adjMat) {
+            row.Add(0);
+        }
+    }
+
+    /* 删除顶点 */
+    public void RemoveVertex(int index) {
+        if (index >= Size())
+            throw new IndexOutOfRangeException();
+        // 在顶点列表中移除索引 index 的顶点
+        vertices.RemoveAt(index);
+        // 在邻接矩阵中删除索引 index 的行
+        adjMat.RemoveAt(index);
+        // 在邻接矩阵中删除索引 index 的列
+        foreach (List<int> row in adjMat) {
+            row.RemoveAt(index);
+        }
+    }
+
+    /* 添加边 */
+    // 参数 i, j 对应 vertices 元素索引
+    public void AddEdge(int i, int j) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)
+            throw new IndexOutOfRangeException();
+        // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+        adjMat[i][j] = 1;
+        adjMat[j][i] = 1;
+    }
+
+    /* 删除边 */
+    // 参数 i, j 对应 vertices 元素索引
+    public void RemoveEdge(int i, int j) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)
+            throw new IndexOutOfRangeException();
+        adjMat[i][j] = 0;
+        adjMat[j][i] = 0;
+    }
+
+    /* 打印邻接矩阵 */
+    public void Print() {
+        Console.Write("顶点列表 = ");
+        PrintUtil.PrintList(vertices);
+        Console.WriteLine("邻接矩阵 =");
+        PrintUtil.PrintMatrix(adjMat);
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.go
    /* 基于邻接矩阵实现的无向图类 */
+type graphAdjMat struct {
+    // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    vertices []int
+    // 邻接矩阵，行列索引对应“顶点索引”
+    adjMat [][]int
+}
+
+/* 构造函数 */
+func newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {
+    // 添加顶点
+    n := len(vertices)
+    adjMat := make([][]int, n)
+    for i := range adjMat {
+        adjMat[i] = make([]int, n)
+    }
+    // 初始化图
+    g := &graphAdjMat{
+        vertices: vertices,
+        adjMat:   adjMat,
+    }
+    // 添加边
+    // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+    for i := range edges {
+        g.addEdge(edges[i][0], edges[i][1])
+    }
+    return g
+}
+
+/* 获取顶点数量 */
+func (g *graphAdjMat) size() int {
+    return len(g.vertices)
+}
+
+/* 添加顶点 */
+func (g *graphAdjMat) addVertex(val int) {
+    n := g.size()
+    // 向顶点列表中添加新顶点的值
+    g.vertices = append(g.vertices, val)
+    // 在邻接矩阵中添加一行
+    newRow := make([]int, n)
+    g.adjMat = append(g.adjMat, newRow)
+    // 在邻接矩阵中添加一列
+    for i := range g.adjMat {
+        g.adjMat[i] = append(g.adjMat[i], 0)
+    }
+}
+
+/* 删除顶点 */
+func (g *graphAdjMat) removeVertex(index int) {
+    if index >= g.size() {
+        return
+    }
+    // 在顶点列表中移除索引 index 的顶点
+    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)
+    // 在邻接矩阵中删除索引 index 的行
+    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)
+    // 在邻接矩阵中删除索引 index 的列
+    for i := range g.adjMat {
+        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)
+    }
+}
+
+/* 添加边 */
+// 参数 i, j 对应 vertices 元素索引
+func (g *graphAdjMat) addEdge(i, j int) {
+    // 索引越界与相等处理
+    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
+        fmt.Errorf("%s", "Index Out Of Bounds Exception")
+    }
+    // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+    g.adjMat[i][j] = 1
+    g.adjMat[j][i] = 1
+}
+
+/* 删除边 */
+// 参数 i, j 对应 vertices 元素索引
+func (g *graphAdjMat) removeEdge(i, j int) {
+    // 索引越界与相等处理
+    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
+        fmt.Errorf("%s", "Index Out Of Bounds Exception")
+    }
+    g.adjMat[i][j] = 0
+    g.adjMat[j][i] = 0
+}
+
+/* 打印邻接矩阵 */
+func (g *graphAdjMat) print() {
+    fmt.Printf("\t顶点列表 = %v\n", g.vertices)
+    fmt.Printf("\t邻接矩阵 = \n")
+    for i := range g.adjMat {
+        fmt.Printf("\t\t\t%v\n", g.adjMat[i])
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.swift
    /* 基于邻接矩阵实现的无向图类 */
+class GraphAdjMat {
+    private var vertices: [Int] // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    private var adjMat: [[Int]] // 邻接矩阵，行列索引对应“顶点索引”
+
+    /* 构造方法 */
+    init(vertices: [Int], edges: [[Int]]) {
+        self.vertices = []
+        adjMat = []
+        // 添加顶点
+        for val in vertices {
+            addVertex(val: val)
+        }
+        // 添加边
+        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        for e in edges {
+            addEdge(i: e[0], j: e[1])
+        }
+    }
+
+    /* 获取顶点数量 */
+    func size() -> Int {
+        vertices.count
+    }
+
+    /* 添加顶点 */
+    func addVertex(val: Int) {
+        let n = size()
+        // 向顶点列表中添加新顶点的值
+        vertices.append(val)
+        // 在邻接矩阵中添加一行
+        let newRow = Array(repeating: 0, count: n)
+        adjMat.append(newRow)
+        // 在邻接矩阵中添加一列
+        for i in adjMat.indices {
+            adjMat[i].append(0)
+        }
+    }
+
+    /* 删除顶点 */
+    func removeVertex(index: Int) {
+        if index >= size() {
+            fatalError("越界")
+        }
+        // 在顶点列表中移除索引 index 的顶点
+        vertices.remove(at: index)
+        // 在邻接矩阵中删除索引 index 的行
+        adjMat.remove(at: index)
+        // 在邻接矩阵中删除索引 index 的列
+        for i in adjMat.indices {
+            adjMat[i].remove(at: index)
+        }
+    }
+
+    /* 添加边 */
+    // 参数 i, j 对应 vertices 元素索引
+    func addEdge(i: Int, j: Int) {
+        // 索引越界与相等处理
+        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {
+            fatalError("越界")
+        }
+        // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+        adjMat[i][j] = 1
+        adjMat[j][i] = 1
+    }
+
+    /* 删除边 */
+    // 参数 i, j 对应 vertices 元素索引
+    func removeEdge(i: Int, j: Int) {
+        // 索引越界与相等处理
+        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {
+            fatalError("越界")
+        }
+        adjMat[i][j] = 0
+        adjMat[j][i] = 0
+    }
+
+    /* 打印邻接矩阵 */
+    func print() {
+        Swift.print("顶点列表 = ", terminator: "")
+        Swift.print(vertices)
+        Swift.print("邻接矩阵 =")
+        PrintUtil.printMatrix(matrix: adjMat)
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.js
    /* 基于邻接矩阵实现的无向图类 */
+class GraphAdjMat {
+    vertices; // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    adjMat; // 邻接矩阵，行列索引对应“顶点索引”
+
+    /* 构造函数 */
+    constructor(vertices, edges) {
+        this.vertices = [];
+        this.adjMat = [];
+        // 添加顶点
+        for (const val of vertices) {
+            this.addVertex(val);
+        }
+        // 添加边
+        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        for (const e of edges) {
+            this.addEdge(e[0], e[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    size() {
+        return this.vertices.length;
+    }
+
+    /* 添加顶点 */
+    addVertex(val) {
+        const n = this.size();
+        // 向顶点列表中添加新顶点的值
+        this.vertices.push(val);
+        // 在邻接矩阵中添加一行
+        const newRow = [];
+        for (let j = 0; j < n; j++) {
+            newRow.push(0);
+        }
+        this.adjMat.push(newRow);
+        // 在邻接矩阵中添加一列
+        for (const row of this.adjMat) {
+            row.push(0);
+        }
+    }
+
+    /* 删除顶点 */
+    removeVertex(index) {
+        if (index >= this.size()) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        // 在顶点列表中移除索引 index 的顶点
+        this.vertices.splice(index, 1);
+
+        // 在邻接矩阵中删除索引 index 的行
+        this.adjMat.splice(index, 1);
+        // 在邻接矩阵中删除索引 index 的列
+        for (const row of this.adjMat) {
+            row.splice(index, 1);
+        }
+    }
+
+    /* 添加边 */
+    // 参数 i, j 对应 vertices 元素索引
+    addEdge(i, j) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) === (j, i)
+        this.adjMat[i][j] = 1;
+        this.adjMat[j][i] = 1;
+    }
+
+    /* 删除边 */
+    // 参数 i, j 对应 vertices 元素索引
+    removeEdge(i, j) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        this.adjMat[i][j] = 0;
+        this.adjMat[j][i] = 0;
+    }
+
+    /* 打印邻接矩阵 */
+    print() {
+        console.log('顶点列表 = ', this.vertices);
+        console.log('邻接矩阵 =', this.adjMat);
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.ts
    /* 基于邻接矩阵实现的无向图类 */
+class GraphAdjMat {
+    vertices: number[]; // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    adjMat: number[][]; // 邻接矩阵，行列索引对应“顶点索引”
+
+    /* 构造函数 */
+    constructor(vertices: number[], edges: number[][]) {
+        this.vertices = [];
+        this.adjMat = [];
+        // 添加顶点
+        for (const val of vertices) {
+            this.addVertex(val);
+        }
+        // 添加边
+        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        for (const e of edges) {
+            this.addEdge(e[0], e[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    size(): number {
+        return this.vertices.length;
+    }
+
+    /* 添加顶点 */
+    addVertex(val: number): void {
+        const n: number = this.size();
+        // 向顶点列表中添加新顶点的值
+        this.vertices.push(val);
+        // 在邻接矩阵中添加一行
+        const newRow: number[] = [];
+        for (let j: number = 0; j < n; j++) {
+            newRow.push(0);
+        }
+        this.adjMat.push(newRow);
+        // 在邻接矩阵中添加一列
+        for (const row of this.adjMat) {
+            row.push(0);
+        }
+    }
+
+    /* 删除顶点 */
+    removeVertex(index: number): void {
+        if (index >= this.size()) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        // 在顶点列表中移除索引 index 的顶点
+        this.vertices.splice(index, 1);
+
+        // 在邻接矩阵中删除索引 index 的行
+        this.adjMat.splice(index, 1);
+        // 在邻接矩阵中删除索引 index 的列
+        for (const row of this.adjMat) {
+            row.splice(index, 1);
+        }
+    }
+
+    /* 添加边 */
+    // 参数 i, j 对应 vertices 元素索引
+    addEdge(i: number, j: number): void {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) === (j, i)
+        this.adjMat[i][j] = 1;
+        this.adjMat[j][i] = 1;
+    }
+
+    /* 删除边 */
+    // 参数 i, j 对应 vertices 元素索引
+    removeEdge(i: number, j: number): void {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
+            throw new RangeError('Index Out Of Bounds Exception');
+        }
+        this.adjMat[i][j] = 0;
+        this.adjMat[j][i] = 0;
+    }
+
+    /* 打印邻接矩阵 */
+    print(): void {
+        console.log('顶点列表 = ', this.vertices);
+        console.log('邻接矩阵 =', this.adjMat);
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.dart
    /* 基于邻接矩阵实现的无向图类 */
+class GraphAdjMat {
+  List<int> vertices = []; // 顶点元素，元素代表“顶点值”，索引代表“顶点索引”
+  List<List<int>> adjMat = []; //邻接矩阵，行列索引对应“顶点索引”
+
+  /* 构造方法 */
+  GraphAdjMat(List<int> vertices, List<List<int>> edges) {
+    this.vertices = [];
+    this.adjMat = [];
+    // 添加顶点
+    for (int val in vertices) {
+      addVertex(val);
+    }
+    // 添加边
+    // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+    for (List<int> e in edges) {
+      addEdge(e[0], e[1]);
+    }
+  }
+
+  /* 获取顶点数量 */
+  int size() {
+    return vertices.length;
+  }
+
+  /* 添加顶点 */
+  void addVertex(int val) {
+    int n = size();
+    // 向顶点列表中添加新顶点的值
+    vertices.add(val);
+    // 在邻接矩阵中添加一行
+    List<int> newRow = List.filled(n, 0, growable: true);
+    adjMat.add(newRow);
+    // 在邻接矩阵中添加一列
+    for (List<int> row in adjMat) {
+      row.add(0);
+    }
+  }
+
+  /* 删除顶点 */
+  void removeVertex(int index) {
+    if (index >= size()) {
+      throw IndexError;
+    }
+    // 在顶点列表中移除索引 index 的顶点
+    vertices.removeAt(index);
+    // 在邻接矩阵中删除索引 index 的行
+    adjMat.removeAt(index);
+    // 在邻接矩阵中删除索引 index 的列
+    for (List<int> row in adjMat) {
+      row.removeAt(index);
+    }
+  }
+
+  /* 添加边 */
+  // 参数 i, j 对应 vertices 元素索引
+  void addEdge(int i, int j) {
+    // 索引越界与相等处理
+    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
+      throw IndexError;
+    }
+    // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+    adjMat[i][j] = 1;
+    adjMat[j][i] = 1;
+  }
+
+  /* 删除边 */
+  // 参数 i, j 对应 vertices 元素索引
+  void removeEdge(int i, int j) {
+    // 索引越界与相等处理
+    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
+      throw IndexError;
+    }
+    adjMat[i][j] = 0;
+    adjMat[j][i] = 0;
+  }
+
+  /* 打印邻接矩阵 */
+  void printAdjMat() {
+    print("顶点列表 = $vertices");
+    print("邻接矩阵 = ");
+    printMatrix(adjMat);
+  }
+}
+
    +
    +
    +
    graph_adjacency_matrix.rs
    /* 基于邻接矩阵实现的无向图类型 */
+pub struct GraphAdjMat {
+    // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    pub vertices: Vec<i32>,
+    // 邻接矩阵，行列索引对应“顶点索引”
+    pub adj_mat: Vec<Vec<i32>>,
+}
+
+impl GraphAdjMat {
+    /* 构造方法 */
+    pub fn new(vertices: Vec<i32>, edges: Vec<[usize; 2]>) -> Self {
+        let mut graph = GraphAdjMat {
+            vertices: vec![],
+            adj_mat: vec![],
+        };
+        // 添加顶点
+        for val in vertices {
+            graph.add_vertex(val);
+        }
+        // 添加边
+        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        for edge in edges {
+            graph.add_edge(edge[0], edge[1])
+        }
+
+        graph
+    }
+
+    /* 获取顶点数量 */
+    pub fn size(&self) -> usize {
+        self.vertices.len()
+    }
+
+    /* 添加顶点 */
+    pub fn add_vertex(&mut self, val: i32) {
+        let n = self.size();
+        // 向顶点列表中添加新顶点的值
+        self.vertices.push(val);
+        // 在邻接矩阵中添加一行
+        self.adj_mat.push(vec![0; n]);
+        // 在邻接矩阵中添加一列
+        for row in &mut self.adj_mat {
+            row.push(0);
+        }
+    }
+
+    /* 删除顶点 */
+    pub fn remove_vertex(&mut self, index: usize) {
+        if index >= self.size() {
+            panic!("index error")
+        }
+        // 在顶点列表中移除索引 index 的顶点
+        self.vertices.remove(index);
+        // 在邻接矩阵中删除索引 index 的行
+        self.adj_mat.remove(index);
+        // 在邻接矩阵中删除索引 index 的列
+        for row in &mut self.adj_mat {
+            row.remove(index);
+        }
+    }
+
+    /* 添加边 */
+    pub fn add_edge(&mut self, i: usize, j: usize) {
+        // 参数 i, j 对应 vertices 元素索引
+        // 索引越界与相等处理
+        if i >= self.size() || j >= self.size() || i == j {
+            panic!("index error")
+        }
+        // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+        self.adj_mat[i][j] = 1;
+        self.adj_mat[j][i] = 1;
+    }
+
+    /* 删除边 */
+    // 参数 i, j 对应 vertices 元素索引
+    pub fn remove_edge(&mut self, i: usize, j: usize) {
+        // 参数 i, j 对应 vertices 元素索引
+        // 索引越界与相等处理
+        if i >= self.size() || j >= self.size() || i == j {
+            panic!("index error")
+        }
+        self.adj_mat[i][j] = 0;
+        self.adj_mat[j][i] = 0;
+    }
+
+    /* 打印邻接矩阵 */
+    pub fn print(&self) {
+        println!("顶点列表 = {:?}", self.vertices);
+        println!("邻接矩阵 =");
+        println!("[");
+        for row in &self.adj_mat {
+            println!("  {:?},", row);
+        }
+        println!("]")
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.c
    /* 基于邻接矩阵实现的无向图结构体 */
+typedef struct {
+    int vertices[MAX_SIZE];
+    int adjMat[MAX_SIZE][MAX_SIZE];
+    int size;
+} GraphAdjMat;
+
+/* 构造函数 */
+GraphAdjMat *newGraphAdjMat() {
+    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));
+    graph->size = 0;
+    for (int i = 0; i < MAX_SIZE; i++) {
+        for (int j = 0; j < MAX_SIZE; j++) {
+            graph->adjMat[i][j] = 0;
+        }
+    }
+    return graph;
+}
+
+/* 析构函数 */
+void delGraphAdjMat(GraphAdjMat *graph) {
+    free(graph);
+}
+
+/* 添加顶点 */
+void addVertex(GraphAdjMat *graph, int val) {
+    if (graph->size == MAX_SIZE) {
+        fprintf(stderr, "图的顶点数量已达最大值\n");
+        return;
+    }
+    // 添加第 n 个顶点，并将第 n 行和列置零
+    int n = graph->size;
+    graph->vertices[n] = val;
+    for (int i = 0; i <= n; i++) {
+        graph->adjMat[n][i] = graph->adjMat[i][n] = 0;
+    }
+    graph->size++;
+}
+
+/* 删除顶点 */
+void removeVertex(GraphAdjMat *graph, int index) {
+    if (index < 0 || index >= graph->size) {
+        fprintf(stderr, "顶点索引越界\n");
+        return;
+    }
+    // 在顶点列表中移除索引 index 的顶点
+    for (int i = index; i < graph->size - 1; i++) {
+        graph->vertices[i] = graph->vertices[i + 1];
+    }
+    // 在邻接矩阵中删除索引 index 的行
+    for (int i = index; i < graph->size - 1; i++) {
+        for (int j = 0; j < graph->size; j++) {
+            graph->adjMat[i][j] = graph->adjMat[i + 1][j];
+        }
+    }
+    // 在邻接矩阵中删除索引 index 的列
+    for (int i = 0; i < graph->size; i++) {
+        for (int j = index; j < graph->size - 1; j++) {
+            graph->adjMat[i][j] = graph->adjMat[i][j + 1];
+        }
+    }
+    graph->size--;
+}
+
+/* 添加边 */
+// 参数 i, j 对应 vertices 元素索引
+void addEdge(GraphAdjMat *graph, int i, int j) {
+    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
+        fprintf(stderr, "边索引越界或相等\n");
+        return;
+    }
+    graph->adjMat[i][j] = 1;
+    graph->adjMat[j][i] = 1;
+}
+
+/* 删除边 */
+// 参数 i, j 对应 vertices 元素索引
+void removeEdge(GraphAdjMat *graph, int i, int j) {
+    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
+        fprintf(stderr, "边索引越界或相等\n");
+        return;
+    }
+    graph->adjMat[i][j] = 0;
+    graph->adjMat[j][i] = 0;
+}
+
+/* 打印邻接矩阵 */
+void printGraphAdjMat(GraphAdjMat *graph) {
+    printf("顶点列表 = ");
+    printArray(graph->vertices, graph->size);
+    printf("邻接矩阵 =\n");
+    for (int i = 0; i < graph->size; i++) {
+        printArray(graph->adjMat[i], graph->size);
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.kt
    /* 基于邻接矩阵实现的无向图类 */
+class GraphAdjMat(vertices: IntArray, edges: Array<IntArray>) {
+    val vertices: MutableList<Int> = ArrayList() // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
+    val adjMat: MutableList<MutableList<Int>> = ArrayList() // 邻接矩阵，行列索引对应“顶点索引”
+
+    /* 构造函数 */
+    init {
+        // 添加顶点
+        for (vertex in vertices) {
+            addVertex(vertex)
+        }
+        // 添加边
+        // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
+        for (edge in edges) {
+            addEdge(edge[0], edge[1])
+        }
+    }
+
+    /* 获取顶点数量 */
+    fun size(): Int {
+        return vertices.size
+    }
+
+    /* 添加顶点 */
+    fun addVertex(value: Int) {
+        val n = size()
+        // 向顶点列表中添加新顶点的值
+        vertices.add(value)
+        // 在邻接矩阵中添加一行
+        val newRow: MutableList<Int> = mutableListOf()
+        for (j in 0..<n) {
+            newRow.add(0)
+        }
+        adjMat.add(newRow)
+        // 在邻接矩阵中添加一列
+        for (row in adjMat) {
+            row.add(0)
+        }
+    }
+
+    /* 删除顶点 */
+    fun removeVertex(index: Int) {
+        if (index >= size()) throw IndexOutOfBoundsException()
+        // 在顶点列表中移除索引 index 的顶点
+        vertices.removeAt(index)
+        // 在邻接矩阵中删除索引 index 的行
+        adjMat.removeAt(index)
+        // 在邻接矩阵中删除索引 index 的列
+        for (row in adjMat) {
+            row.removeAt(index)
+        }
+    }
+
+    /* 添加边 */
+    // 参数 i, j 对应 vertices 元素索引
+    fun addEdge(i: Int, j: Int) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) throw java.lang.IndexOutOfBoundsException()
+        // 在无向图中，邻接矩阵关于主对角线对称，即满足 (i, j) == (j, i)
+        adjMat[i][j] = 1;
+        adjMat[j][i] = 1;
+    }
+
+    /* 删除边 */
+    // 参数 i, j 对应 vertices 元素索引
+    fun removeEdge(i: Int, j: Int) {
+        // 索引越界与相等处理
+        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) throw java.lang.IndexOutOfBoundsException()
+        adjMat[i][j] = 0;
+        adjMat[j][i] = 0;
+    }
+
+    /* 打印邻接矩阵 */
+    fun print() {
+        print("顶点列表 = ")
+        println(vertices);
+        println("邻接矩阵 =");
+        printMatrix(adjMat)
+    }
+}
+
    +
    +
    +
    graph_adjacency_matrix.rb
    [class]{GraphAdjMat}-[func]{}
+
    +
    +
    +
    graph_adjacency_matrix.zig
    [class]{GraphAdjMat}-[func]{}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    9.2.2   Implementation based on adjacency list

    +

    Given an undirected graph with a total of \(n\) vertices and \(m\) edges, the various operations can be implemented as shown in the Figure 9-8 .

    +
      +
    • Adding an edge: Simply add the edge at the end of the corresponding vertex's linked list, using \(O(1)\) time. Because it is an undirected graph, it is necessary to add edges in both directions simultaneously.
      • +
    • Removing an edge: Find and remove the specified edge in the corresponding vertex's linked list, using \(O(m)\) time. In an undirected graph, it is necessary to remove edges in both directions simultaneously.
      • +
    • Adding a vertex: Add a linked list in the adjacency list and make the new vertex the head node of the list, using \(O(1)\) time.
      • +
    • Removing a vertex: It is necessary to traverse the entire adjacency list, removing all edges that include the specified vertex, using \(O(n + m)\) time.
      • +
    • Initialization: Create \(n\) vertices and \(2m\) edges in the adjacency list, using \(O(n + m)\) time.
      • +
    +
    +
    +
    +

    Initialization, adding and removing edges, adding and removing vertices in adjacency list

    +
    +
    +

    adjacency_list_add_edge

    +
    +
    +

    adjacency_list_remove_edge

    +
    +
    +

    adjacency_list_add_vertex

    +
    +
    +

    adjacency_list_remove_vertex

    +
    +
    +
    +

    Figure 9-8   Initialization, adding and removing edges, adding and removing vertices in adjacency list

    + +

    Below is the adjacency list code implementation. Compared to the above diagram, the actual code has the following differences.

    +
      +
    • For convenience in adding and removing vertices, and to simplify the code, we use lists (dynamic arrays) instead of linked lists.
      • +
    • Use a hash table to store the adjacency list, key being the vertex instance, value being the list (linked list) of adjacent vertices of that vertex.
      • +
    +

    Additionally, we use the Vertex class to represent vertices in the adjacency list. The reason for this is: if, like with the adjacency matrix, list indexes were used to distinguish different vertices, then suppose you want to delete the vertex at index \(i\), you would need to traverse the entire adjacency list and decrement all indexes greater than \(i\) by \(1\), which is very inefficient. However, if each vertex is a unique Vertex instance, then deleting a vertex does not require any changes to other vertices.

    +
    +
    +
    +
    graph_adjacency_list.py
    class GraphAdjList:
+    """基于邻接表实现的无向图类"""
+
+    def __init__(self, edges: list[list[Vertex]]):
+        """构造方法"""
+        # 邻接表，key：顶点，value：该顶点的所有邻接顶点
+        self.adj_list = dict[Vertex, list[Vertex]]()
+        # 添加所有顶点和边
+        for edge in edges:
+            self.add_vertex(edge[0])
+            self.add_vertex(edge[1])
+            self.add_edge(edge[0], edge[1])
+
+    def size(self) -> int:
+        """获取顶点数量"""
+        return len(self.adj_list)
+
+    def add_edge(self, vet1: Vertex, vet2: Vertex):
+        """添加边"""
+        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:
+            raise ValueError()
+        # 添加边 vet1 - vet2
+        self.adj_list[vet1].append(vet2)
+        self.adj_list[vet2].append(vet1)
+
+    def remove_edge(self, vet1: Vertex, vet2: Vertex):
+        """删除边"""
+        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:
+            raise ValueError()
+        # 删除边 vet1 - vet2
+        self.adj_list[vet1].remove(vet2)
+        self.adj_list[vet2].remove(vet1)
+
+    def add_vertex(self, vet: Vertex):
+        """添加顶点"""
+        if vet in self.adj_list:
+            return
+        # 在邻接表中添加一个新链表
+        self.adj_list[vet] = []
+
+    def remove_vertex(self, vet: Vertex):
+        """删除顶点"""
+        if vet not in self.adj_list:
+            raise ValueError()
+        # 在邻接表中删除顶点 vet 对应的链表
+        self.adj_list.pop(vet)
+        # 遍历其他顶点的链表，删除所有包含 vet 的边
+        for vertex in self.adj_list:
+            if vet in self.adj_list[vertex]:
+                self.adj_list[vertex].remove(vet)
+
+    def print(self):
+        """打印邻接表"""
+        print("邻接表 =")
+        for vertex in self.adj_list:
+            tmp = [v.val for v in self.adj_list[vertex]]
+            print(f"{vertex.val}: {tmp},")
+
    +
    +
    +
    graph_adjacency_list.cpp
    /* 基于邻接表实现的无向图类 */
+class GraphAdjList {
+  public:
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    unordered_map<Vertex *, vector<Vertex *>> adjList;
+
+    /* 在 vector 中删除指定节点 */
+    void remove(vector<Vertex *> &vec, Vertex *vet) {
+        for (int i = 0; i < vec.size(); i++) {
+            if (vec[i] == vet) {
+                vec.erase(vec.begin() + i);
+                break;
+            }
+        }
+    }
+
+    /* 构造方法 */
+    GraphAdjList(const vector<vector<Vertex *>> &edges) {
+        // 添加所有顶点和边
+        for (const vector<Vertex *> &edge : edges) {
+            addVertex(edge[0]);
+            addVertex(edge[1]);
+            addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    int size() {
+        return adjList.size();
+    }
+
+    /* 添加边 */
+    void addEdge(Vertex *vet1, Vertex *vet2) {
+        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
+            throw invalid_argument("不存在顶点");
+        // 添加边 vet1 - vet2
+        adjList[vet1].push_back(vet2);
+        adjList[vet2].push_back(vet1);
+    }
+
+    /* 删除边 */
+    void removeEdge(Vertex *vet1, Vertex *vet2) {
+        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)
+            throw invalid_argument("不存在顶点");
+        // 删除边 vet1 - vet2
+        remove(adjList[vet1], vet2);
+        remove(adjList[vet2], vet1);
+    }
+
+    /* 添加顶点 */
+    void addVertex(Vertex *vet) {
+        if (adjList.count(vet))
+            return;
+        // 在邻接表中添加一个新链表
+        adjList[vet] = vector<Vertex *>();
+    }
+
+    /* 删除顶点 */
+    void removeVertex(Vertex *vet) {
+        if (!adjList.count(vet))
+            throw invalid_argument("不存在顶点");
+        // 在邻接表中删除顶点 vet 对应的链表
+        adjList.erase(vet);
+        // 遍历其他顶点的链表，删除所有包含 vet 的边
+        for (auto &adj : adjList) {
+            remove(adj.second, vet);
+        }
+    }
+
+    /* 打印邻接表 */
+    void print() {
+        cout << "邻接表 =" << endl;
+        for (auto &adj : adjList) {
+            const auto &key = adj.first;
+            const auto &vec = adj.second;
+            cout << key->val << ": ";
+            printVector(vetsToVals(vec));
+        }
+    }
+};
+
    +
    +
    +
    graph_adjacency_list.java
    /* 基于邻接表实现的无向图类 */
+class GraphAdjList {
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    Map<Vertex, List<Vertex>> adjList;
+
+    /* 构造方法 */
+    public GraphAdjList(Vertex[][] edges) {
+        this.adjList = new HashMap<>();
+        // 添加所有顶点和边
+        for (Vertex[] edge : edges) {
+            addVertex(edge[0]);
+            addVertex(edge[1]);
+            addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    public int size() {
+        return adjList.size();
+    }
+
+    /* 添加边 */
+    public void addEdge(Vertex vet1, Vertex vet2) {
+        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
+            throw new IllegalArgumentException();
+        // 添加边 vet1 - vet2
+        adjList.get(vet1).add(vet2);
+        adjList.get(vet2).add(vet1);
+    }
+
+    /* 删除边 */
+    public void removeEdge(Vertex vet1, Vertex vet2) {
+        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
+            throw new IllegalArgumentException();
+        // 删除边 vet1 - vet2
+        adjList.get(vet1).remove(vet2);
+        adjList.get(vet2).remove(vet1);
+    }
+
+    /* 添加顶点 */
+    public void addVertex(Vertex vet) {
+        if (adjList.containsKey(vet))
+            return;
+        // 在邻接表中添加一个新链表
+        adjList.put(vet, new ArrayList<>());
+    }
+
+    /* 删除顶点 */
+    public void removeVertex(Vertex vet) {
+        if (!adjList.containsKey(vet))
+            throw new IllegalArgumentException();
+        // 在邻接表中删除顶点 vet 对应的链表
+        adjList.remove(vet);
+        // 遍历其他顶点的链表，删除所有包含 vet 的边
+        for (List<Vertex> list : adjList.values()) {
+            list.remove(vet);
+        }
+    }
+
+    /* 打印邻接表 */
+    public void print() {
+        System.out.println("邻接表 =");
+        for (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {
+            List<Integer> tmp = new ArrayList<>();
+            for (Vertex vertex : pair.getValue())
+                tmp.add(vertex.val);
+            System.out.println(pair.getKey().val + ": " + tmp + ",");
+        }
+    }
+}
+
    +
    +
    +
    graph_adjacency_list.cs
    /* 基于邻接表实现的无向图类 */
+class GraphAdjList {
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    public Dictionary<Vertex, List<Vertex>> adjList;
+
+    /* 构造函数 */
+    public GraphAdjList(Vertex[][] edges) {
+        adjList = [];
+        // 添加所有顶点和边
+        foreach (Vertex[] edge in edges) {
+            AddVertex(edge[0]);
+            AddVertex(edge[1]);
+            AddEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    int Size() {
+        return adjList.Count;
+    }
+
+    /* 添加边 */
+    public void AddEdge(Vertex vet1, Vertex vet2) {
+        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)
+            throw new InvalidOperationException();
+        // 添加边 vet1 - vet2
+        adjList[vet1].Add(vet2);
+        adjList[vet2].Add(vet1);
+    }
+
+    /* 删除边 */
+    public void RemoveEdge(Vertex vet1, Vertex vet2) {
+        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)
+            throw new InvalidOperationException();
+        // 删除边 vet1 - vet2
+        adjList[vet1].Remove(vet2);
+        adjList[vet2].Remove(vet1);
+    }
+
+    /* 添加顶点 */
+    public void AddVertex(Vertex vet) {
+        if (adjList.ContainsKey(vet))
+            return;
+        // 在邻接表中添加一个新链表
+        adjList.Add(vet, []);
+    }
+
+    /* 删除顶点 */
+    public void RemoveVertex(Vertex vet) {
+        if (!adjList.ContainsKey(vet))
+            throw new InvalidOperationException();
+        // 在邻接表中删除顶点 vet 对应的链表
+        adjList.Remove(vet);
+        // 遍历其他顶点的链表，删除所有包含 vet 的边
+        foreach (List<Vertex> list in adjList.Values) {
+            list.Remove(vet);
+        }
+    }
+
+    /* 打印邻接表 */
+    public void Print() {
+        Console.WriteLine("邻接表 =");
+        foreach (KeyValuePair<Vertex, List<Vertex>> pair in adjList) {
+            List<int> tmp = [];
+            foreach (Vertex vertex in pair.Value)
+                tmp.Add(vertex.val);
+            Console.WriteLine(pair.Key.val + ": [" + string.Join(", ", tmp) + "],");
+        }
+    }
+}
+
    +
    +
    +
    graph_adjacency_list.go
    /* 基于邻接表实现的无向图类 */
+type graphAdjList struct {
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    adjList map[Vertex][]Vertex
+}
+
+/* 构造函数 */
+func newGraphAdjList(edges [][]Vertex) *graphAdjList {
+    g := &graphAdjList{
+        adjList: make(map[Vertex][]Vertex),
+    }
+    // 添加所有顶点和边
+    for _, edge := range edges {
+        g.addVertex(edge[0])
+        g.addVertex(edge[1])
+        g.addEdge(edge[0], edge[1])
+    }
+    return g
+}
+
+/* 获取顶点数量 */
+func (g *graphAdjList) size() int {
+    return len(g.adjList)
+}
+
+/* 添加边 */
+func (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {
+    _, ok1 := g.adjList[vet1]
+    _, ok2 := g.adjList[vet2]
+    if !ok1 || !ok2 || vet1 == vet2 {
+        panic("error")
+    }
+    // 添加边 vet1 - vet2, 添加匿名 struct{},
+    g.adjList[vet1] = append(g.adjList[vet1], vet2)
+    g.adjList[vet2] = append(g.adjList[vet2], vet1)
+}
+
+/* 删除边 */
+func (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {
+    _, ok1 := g.adjList[vet1]
+    _, ok2 := g.adjList[vet2]
+    if !ok1 || !ok2 || vet1 == vet2 {
+        panic("error")
+    }
+    // 删除边 vet1 - vet2
+    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)
+    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)
+}
+
+/* 添加顶点 */
+func (g *graphAdjList) addVertex(vet Vertex) {
+    _, ok := g.adjList[vet]
+    if ok {
+        return
+    }
+    // 在邻接表中添加一个新链表
+    g.adjList[vet] = make([]Vertex, 0)
+}
+
+/* 删除顶点 */
+func (g *graphAdjList) removeVertex(vet Vertex) {
+    _, ok := g.adjList[vet]
+    if !ok {
+        panic("error")
+    }
+    // 在邻接表中删除顶点 vet 对应的链表
+    delete(g.adjList, vet)
+    // 遍历其他顶点的链表，删除所有包含 vet 的边
+    for v, list := range g.adjList {
+        g.adjList[v] = DeleteSliceElms(list, vet)
+    }
+}
+
+/* 打印邻接表 */
+func (g *graphAdjList) print() {
+    var builder strings.Builder
+    fmt.Printf("邻接表 = \n")
+    for k, v := range g.adjList {
+        builder.WriteString("\t\t" + strconv.Itoa(k.Val) + ": ")
+        for _, vet := range v {
+            builder.WriteString(strconv.Itoa(vet.Val) + " ")
+        }
+        fmt.Println(builder.String())
+        builder.Reset()
+    }
+}
+
    +
    +
    +
    graph_adjacency_list.swift
    /* 基于邻接表实现的无向图类 */
+class GraphAdjList {
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    public private(set) var adjList: [Vertex: [Vertex]]
+
+    /* 构造方法 */
+    public init(edges: [[Vertex]]) {
+        adjList = [:]
+        // 添加所有顶点和边
+        for edge in edges {
+            addVertex(vet: edge[0])
+            addVertex(vet: edge[1])
+            addEdge(vet1: edge[0], vet2: edge[1])
+        }
+    }
+
+    /* 获取顶点数量 */
+    public func size() -> Int {
+        adjList.count
+    }
+
+    /* 添加边 */
+    public func addEdge(vet1: Vertex, vet2: Vertex) {
+        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {
+            fatalError("参数错误")
+        }
+        // 添加边 vet1 - vet2
+        adjList[vet1]?.append(vet2)
+        adjList[vet2]?.append(vet1)
+    }
+
+    /* 删除边 */
+    public func removeEdge(vet1: Vertex, vet2: Vertex) {
+        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {
+            fatalError("参数错误")
+        }
+        // 删除边 vet1 - vet2
+        adjList[vet1]?.removeAll { $0 == vet2 }
+        adjList[vet2]?.removeAll { $0 == vet1 }
+    }
+
+    /* 添加顶点 */
+    public func addVertex(vet: Vertex) {
+        if adjList[vet] != nil {
+            return
+        }
+        // 在邻接表中添加一个新链表
+        adjList[vet] = []
+    }
+
+    /* 删除顶点 */
+    public func removeVertex(vet: Vertex) {
+        if adjList[vet] == nil {
+            fatalError("参数错误")
+        }
+        // 在邻接表中删除顶点 vet 对应的链表
+        adjList.removeValue(forKey: vet)
+        // 遍历其他顶点的链表，删除所有包含 vet 的边
+        for key in adjList.keys {
+            adjList[key]?.removeAll { $0 == vet }
+        }
+    }
+
+    /* 打印邻接表 */
+    public func print() {
+        Swift.print("邻接表 =")
+        for (vertex, list) in adjList {
+            let list = list.map { $0.val }
+            Swift.print("\(vertex.val): \(list),")
+        }
+    }
+}
+
    +
    +
    +
    graph_adjacency_list.js
    /* 基于邻接表实现的无向图类 */
+class GraphAdjList {
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    adjList;
+
+    /* 构造方法 */
+    constructor(edges) {
+        this.adjList = new Map();
+        // 添加所有顶点和边
+        for (const edge of edges) {
+            this.addVertex(edge[0]);
+            this.addVertex(edge[1]);
+            this.addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    size() {
+        return this.adjList.size;
+    }
+
+    /* 添加边 */
+    addEdge(vet1, vet2) {
+        if (
+            !this.adjList.has(vet1) ||
+            !this.adjList.has(vet2) ||
+            vet1 === vet2
+        ) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // 添加边 vet1 - vet2
+        this.adjList.get(vet1).push(vet2);
+        this.adjList.get(vet2).push(vet1);
+    }
+
+    /* 删除边 */
+    removeEdge(vet1, vet2) {
+        if (
+            !this.adjList.has(vet1) ||
+            !this.adjList.has(vet2) ||
+            vet1 === vet2
+        ) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // 删除边 vet1 - vet2
+        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);
+        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);
+    }
+
+    /* 添加顶点 */
+    addVertex(vet) {
+        if (this.adjList.has(vet)) return;
+        // 在邻接表中添加一个新链表
+        this.adjList.set(vet, []);
+    }
+
+    /* 删除顶点 */
+    removeVertex(vet) {
+        if (!this.adjList.has(vet)) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // 在邻接表中删除顶点 vet 对应的链表
+        this.adjList.delete(vet);
+        // 遍历其他顶点的链表，删除所有包含 vet 的边
+        for (const set of this.adjList.values()) {
+            const index = set.indexOf(vet);
+            if (index > -1) {
+                set.splice(index, 1);
+            }
+        }
+    }
+
+    /* 打印邻接表 */
+    print() {
+        console.log('邻接表 =');
+        for (const [key, value] of this.adjList) {
+            const tmp = [];
+            for (const vertex of value) {
+                tmp.push(vertex.val);
+            }
+            console.log(key.val + ': ' + tmp.join());
+        }
+    }
+}
+
    +
    +
    +
    graph_adjacency_list.ts
    /* 基于邻接表实现的无向图类 */
+class GraphAdjList {
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    adjList: Map<Vertex, Vertex[]>;
+
+    /* 构造方法 */
+    constructor(edges: Vertex[][]) {
+        this.adjList = new Map();
+        // 添加所有顶点和边
+        for (const edge of edges) {
+            this.addVertex(edge[0]);
+            this.addVertex(edge[1]);
+            this.addEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* 获取顶点数量 */
+    size(): number {
+        return this.adjList.size;
+    }
+
+    /* 添加边 */
+    addEdge(vet1: Vertex, vet2: Vertex): void {
+        if (
+            !this.adjList.has(vet1) ||
+            !this.adjList.has(vet2) ||
+            vet1 === vet2
+        ) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // 添加边 vet1 - vet2
+        this.adjList.get(vet1).push(vet2);
+        this.adjList.get(vet2).push(vet1);
+    }
+
+    /* 删除边 */
+    removeEdge(vet1: Vertex, vet2: Vertex): void {
+        if (
+            !this.adjList.has(vet1) ||
+            !this.adjList.has(vet2) ||
+            vet1 === vet2
+        ) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // 删除边 vet1 - vet2
+        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);
+        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);
+    }
+
+    /* 添加顶点 */
+    addVertex(vet: Vertex): void {
+        if (this.adjList.has(vet)) return;
+        // 在邻接表中添加一个新链表
+        this.adjList.set(vet, []);
+    }
+
+    /* 删除顶点 */
+    removeVertex(vet: Vertex): void {
+        if (!this.adjList.has(vet)) {
+            throw new Error('Illegal Argument Exception');
+        }
+        // 在邻接表中删除顶点 vet 对应的链表
+        this.adjList.delete(vet);
+        // 遍历其他顶点的链表，删除所有包含 vet 的边
+        for (const set of this.adjList.values()) {
+            const index: number = set.indexOf(vet);
+            if (index > -1) {
+                set.splice(index, 1);
+            }
+        }
+    }
+
+    /* 打印邻接表 */
+    print(): void {
+        console.log('邻接表 =');
+        for (const [key, value] of this.adjList.entries()) {
+            const tmp = [];
+            for (const vertex of value) {
+                tmp.push(vertex.val);
+            }
+            console.log(key.val + ': ' + tmp.join());
+        }
+    }
+}
+
    +
    +
    +
    graph_adjacency_list.dart
    /* 基于邻接表实现的无向图类 */
+class GraphAdjList {
+  // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+  Map<Vertex, List<Vertex>> adjList = {};
+
+  /* 构造方法 */
+  GraphAdjList(List<List<Vertex>> edges) {
+    for (List<Vertex> edge in edges) {
+      addVertex(edge[0]);
+      addVertex(edge[1]);
+      addEdge(edge[0], edge[1]);
+    }
+  }
+
+  /* 获取顶点数量 */
+  int size() {
+    return adjList.length;
+  }
+
+  /* 添加边 */
+  void addEdge(Vertex vet1, Vertex vet2) {
+    if (!adjList.containsKey(vet1) ||
+        !adjList.containsKey(vet2) ||
+        vet1 == vet2) {
+      throw ArgumentError;
+    }
+    // 添加边 vet1 - vet2
+    adjList[vet1]!.add(vet2);
+    adjList[vet2]!.add(vet1);
+  }
+
+  /* 删除边 */
+  void removeEdge(Vertex vet1, Vertex vet2) {
+    if (!adjList.containsKey(vet1) ||
+        !adjList.containsKey(vet2) ||
+        vet1 == vet2) {
+      throw ArgumentError;
+    }
+    // 删除边 vet1 - vet2
+    adjList[vet1]!.remove(vet2);
+    adjList[vet2]!.remove(vet1);
+  }
+
+  /* 添加顶点 */
+  void addVertex(Vertex vet) {
+    if (adjList.containsKey(vet)) return;
+    // 在邻接表中添加一个新链表
+    adjList[vet] = [];
+  }
+
+  /* 删除顶点 */
+  void removeVertex(Vertex vet) {
+    if (!adjList.containsKey(vet)) {
+      throw ArgumentError;
+    }
+    // 在邻接表中删除顶点 vet 对应的链表
+    adjList.remove(vet);
+    // 遍历其他顶点的链表，删除所有包含 vet 的边
+    adjList.forEach((key, value) {
+      value.remove(vet);
+    });
+  }
+
+  /* 打印邻接表 */
+  void printAdjList() {
+    print("邻接表 =");
+    adjList.forEach((key, value) {
+      List<int> tmp = [];
+      for (Vertex vertex in value) {
+        tmp.add(vertex.val);
+      }
+      print("${key.val}: $tmp,");
+    });
+  }
+}
+
    +
    +
    +
    graph_adjacency_list.rs
    /* 基于邻接表实现的无向图类型 */
+pub struct GraphAdjList {
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    pub adj_list: HashMap<Vertex, Vec<Vertex>>,
+}
+
+impl GraphAdjList {
+    /* 构造方法 */
+    pub fn new(edges: Vec<[Vertex; 2]>) -> Self {
+        let mut graph = GraphAdjList {
+            adj_list: HashMap::new(),
+        };
+        // 添加所有顶点和边
+        for edge in edges {
+            graph.add_vertex(edge[0]);
+            graph.add_vertex(edge[1]);
+            graph.add_edge(edge[0], edge[1]);
+        }
+
+        graph
+    }
+
+    /* 获取顶点数量 */
+    #[allow(unused)]
+    pub fn size(&self) -> usize {
+        self.adj_list.len()
+    }
+
+    /* 添加边 */
+    pub fn add_edge(&mut self, vet1: Vertex, vet2: Vertex) {
+        if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
+        {
+            panic!("value error");
+        }
+        // 添加边 vet1 - vet2
+        self.adj_list.get_mut(&vet1).unwrap().push(vet2);
+        self.adj_list.get_mut(&vet2).unwrap().push(vet1);
+    }
+
+    /* 删除边 */
+    #[allow(unused)]
+    pub fn remove_edge(&mut self, vet1: Vertex, vet2: Vertex) {
+        if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2
+        {
+            panic!("value error");
+        }
+        // 删除边 vet1 - vet2
+        self.adj_list
+            .get_mut(&vet1)
+            .unwrap()
+            .retain(|&vet| vet != vet2);
+        self.adj_list
+            .get_mut(&vet2)
+            .unwrap()
+            .retain(|&vet| vet != vet1);
+    }
+
+    /* 添加顶点 */
+    pub fn add_vertex(&mut self, vet: Vertex) {
+        if self.adj_list.contains_key(&vet) {
+            return;
+        }
+        // 在邻接表中添加一个新链表
+        self.adj_list.insert(vet, vec![]);
+    }
+
+    /* 删除顶点 */
+    #[allow(unused)]
+    pub fn remove_vertex(&mut self, vet: Vertex) {
+        if !self.adj_list.contains_key(&vet) {
+            panic!("value error");
+        }
+        // 在邻接表中删除顶点 vet 对应的链表
+        self.adj_list.remove(&vet);
+        // 遍历其他顶点的链表，删除所有包含 vet 的边
+        for list in self.adj_list.values_mut() {
+            list.retain(|&v| v != vet);
+        }
+    }
+
+    /* 打印邻接表 */
+    pub fn print(&self) {
+        println!("邻接表 =");
+        for (vertex, list) in &self.adj_list {
+            let list = list.iter().map(|vertex| vertex.val).collect::<Vec<i32>>();
+            println!("{}: {:?},", vertex.val, list);
+        }
+    }
+}
+
    +
    +
    +
    graph_adjacency_list.c
    /* 节点结构体 */
+typedef struct AdjListNode {
+    Vertex *vertex;           // 顶点
+    struct AdjListNode *next; // 后继节点
+} AdjListNode;
+
+/* 查找顶点对应的节点 */
+AdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {
+    for (int i = 0; i < graph->size; i++) {
+        if (graph->heads[i]->vertex == vet) {
+            return graph->heads[i];
+        }
+    }
+    return NULL;
+}
+
+/* 添加边辅助函数 */
+void addEdgeHelper(AdjListNode *head, Vertex *vet) {
+    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));
+    node->vertex = vet;
+    // 头插法
+    node->next = head->next;
+    head->next = node;
+}
+
+/* 删除边辅助函数 */
+void removeEdgeHelper(AdjListNode *head, Vertex *vet) {
+    AdjListNode *pre = head;
+    AdjListNode *cur = head->next;
+    // 在链表中搜索 vet 对应节点
+    while (cur != NULL && cur->vertex != vet) {
+        pre = cur;
+        cur = cur->next;
+    }
+    if (cur == NULL)
+        return;
+    // 将 vet 对应节点从链表中删除
+    pre->next = cur->next;
+    // 释放内存
+    free(cur);
+}
+
+/* 基于邻接表实现的无向图类 */
+typedef struct {
+    AdjListNode *heads[MAX_SIZE]; // 节点数组
+    int size;                     // 节点数量
+} GraphAdjList;
+
+/* 构造函数 */
+GraphAdjList *newGraphAdjList() {
+    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));
+    if (!graph) {
+        return NULL;
+    }
+    graph->size = 0;
+    for (int i = 0; i < MAX_SIZE; i++) {
+        graph->heads[i] = NULL;
+    }
+    return graph;
+}
+
+/* 析构函数 */
+void delGraphAdjList(GraphAdjList *graph) {
+    for (int i = 0; i < graph->size; i++) {
+        AdjListNode *cur = graph->heads[i];
+        while (cur != NULL) {
+            AdjListNode *next = cur->next;
+            if (cur != graph->heads[i]) {
+                free(cur);
+            }
+            cur = next;
+        }
+        free(graph->heads[i]->vertex);
+        free(graph->heads[i]);
+    }
+    free(graph);
+}
+
+/* 查找顶点对应的节点 */
+AdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {
+    for (int i = 0; i < graph->size; i++) {
+        if (graph->heads[i]->vertex == vet) {
+            return graph->heads[i];
+        }
+    }
+    return NULL;
+}
+
+/* 添加边 */
+void addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {
+    AdjListNode *head1 = findNode(graph, vet1);
+    AdjListNode *head2 = findNode(graph, vet2);
+    assert(head1 != NULL && head2 != NULL && head1 != head2);
+    // 添加边 vet1 - vet2
+    addEdgeHelper(head1, vet2);
+    addEdgeHelper(head2, vet1);
+}
+
+/* 删除边 */
+void removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {
+    AdjListNode *head1 = findNode(graph, vet1);
+    AdjListNode *head2 = findNode(graph, vet2);
+    assert(head1 != NULL && head2 != NULL);
+    // 删除边 vet1 - vet2
+    removeEdgeHelper(head1, head2->vertex);
+    removeEdgeHelper(head2, head1->vertex);
+}
+
+/* 添加顶点 */
+void addVertex(GraphAdjList *graph, Vertex *vet) {
+    assert(graph != NULL && graph->size < MAX_SIZE);
+    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));
+    head->vertex = vet;
+    head->next = NULL;
+    // 在邻接表中添加一个新链表
+    graph->heads[graph->size++] = head;
+}
+
+/* 删除顶点 */
+void removeVertex(GraphAdjList *graph, Vertex *vet) {
+    AdjListNode *node = findNode(graph, vet);
+    assert(node != NULL);
+    // 在邻接表中删除顶点 vet 对应的链表
+    AdjListNode *cur = node, *pre = NULL;
+    while (cur) {
+        pre = cur;
+        cur = cur->next;
+        free(pre);
+    }
+    // 遍历其他顶点的链表，删除所有包含 vet 的边
+    for (int i = 0; i < graph->size; i++) {
+        cur = graph->heads[i];
+        pre = NULL;
+        while (cur) {
+            pre = cur;
+            cur = cur->next;
+            if (cur && cur->vertex == vet) {
+                pre->next = cur->next;
+                free(cur);
+                break;
+            }
+        }
+    }
+    // 将该顶点之后的顶点向前移动，以填补空缺
+    int i;
+    for (i = 0; i < graph->size; i++) {
+        if (graph->heads[i] == node)
+            break;
+    }
+    for (int j = i; j < graph->size - 1; j++) {
+        graph->heads[j] = graph->heads[j + 1];
+    }
+    graph->size--;
+    free(vet);
+}
+
    +
    +
    +
    graph_adjacency_list.kt
    /* 基于邻接表实现的无向图类 */
+class GraphAdjList(edges: Array<Array<Vertex?>>) {
+    // 邻接表，key：顶点，value：该顶点的所有邻接顶点
+    val adjList: MutableMap<Vertex, MutableList<Vertex>> = HashMap()
+
+    /* 构造函数 */
+    init {
+        // 添加所有顶点和边
+        for (edge in edges) {
+            addVertex(edge[0]!!);
+            addVertex(edge[1]!!);
+            addEdge(edge[0]!!, edge[1]!!);
+        }
+    }
+
+    /* 获取顶点数量 */
+    fun size(): Int {
+        return adjList.size
+    }
+
+    /* 添加边 */
+    fun addEdge(vet1: Vertex, vet2: Vertex) {
+        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
+            throw IllegalArgumentException()
+        // 添加边 vet1 - vet2
+        adjList[vet1]?.add(vet2)
+        adjList[vet2]?.add(vet1);
+    }
+
+    /* 删除边 */
+    fun removeEdge(vet1: Vertex, vet2: Vertex) {
+        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
+            throw IllegalArgumentException()
+        // 删除边 vet1 - vet2
+        adjList[vet1]?.remove(vet2);
+        adjList[vet2]?.remove(vet1);
+    }
+
+    /* 添加顶点 */
+    fun addVertex(vet: Vertex) {
+        if (adjList.containsKey(vet))
+            return
+        // 在邻接表中添加一个新链表
+        adjList[vet] = mutableListOf()
+    }
+
+    /* 删除顶点 */
+    fun removeVertex(vet: Vertex) {
+        if (!adjList.containsKey(vet))
+            throw IllegalArgumentException()
+        // 在邻接表中删除顶点 vet 对应的链表
+        adjList.remove(vet);
+        // 遍历其他顶点的链表，删除所有包含 vet 的边
+        for (list in adjList.values) {
+            list.remove(vet)
+        }
+    }
+
+    /* 打印邻接表 */
+    fun print() {
+        println("邻接表 =")
+        for (pair in adjList.entries) {
+            val tmp = ArrayList<Int>()
+            for (vertex in pair.value) {
+                tmp.add(vertex.value)
+            }
+            println("${pair.key.value}: $tmp,")
+        }
+    }
+}
+
    +
    +
    +
    graph_adjacency_list.rb
    [class]{GraphAdjList}-[func]{}
+
    +
    +
    +
    graph_adjacency_list.zig
    [class]{GraphAdjList}-[func]{}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    9.2.3   Efficiency comparison

    +

    Assuming there are \(n\) vertices and \(m\) edges in the graph, the Table 9-2 compares the time efficiency and space efficiency of the adjacency matrix and adjacency list.

    +

    Table 9-2   Comparison of adjacency matrix and adjacency list

    + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Adjacency matrixAdjacency list (Linked list)Adjacency list (Hash table)
    Determine adjacency\(O(1)\)\(O(m)\)\(O(1)\)
    Add an edge\(O(1)\)\(O(1)\)\(O(1)\)
    Remove an edge\(O(1)\)\(O(m)\)\(O(1)\)
    Add a vertex\(O(n)\)\(O(1)\)\(O(1)\)
    Remove a vertex\(O(n^2)\)\(O(n + m)\)\(O(n)\)
    Memory space usage\(O(n^2)\)\(O(n + m)\)\(O(n + m)\)
    +
    +

    Observing the Table 9-2 , it seems that the adjacency list (hash table) has the best time efficiency and space efficiency. However, in practice, operating on edges in the adjacency matrix is more efficient, requiring only a single array access or assignment operation. Overall, the adjacency matrix exemplifies the principle of "space for time", while the adjacency list exemplifies "time for space".

    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_graph/graph_traversal.assets/graph_bfs.png b/en/chapter_graph/graph_traversal.assets/graph_bfs.png new file mode 100644 index 0000000000000000000000000000000000000000..96a68291f4131d0825ade6ef659e53834d77e720 GIT binary patch literal 23492 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 Ob*(J$r)-pQ) literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_bfs_step10.png b/en/chapter_graph/graph_traversal.assets/graph_bfs_step10.png new file mode 100644 index 0000000000000000000000000000000000000000..e36b33d393303bd7d1de4b68b8c0b4ac0aa7190b GIT binary patch literal 37007 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_bfs_step11.png b/en/chapter_graph/graph_traversal.assets/graph_bfs_step11.png new file mode 100644 index 0000000000000000000000000000000000000000..08ee4e9d07c31ec720f2ba509204466a97348301 GIT binary patch literal 28059 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_bfs_step2.png b/en/chapter_graph/graph_traversal.assets/graph_bfs_step2.png new file mode 100644 index 0000000000000000000000000000000000000000..55f1b3da0c7babb0f25b63122c1afd789f17e8f0 GIT binary patch literal 30528 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

    EVujQ)djy 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

    -Gm@z$O=7%4t!d?qob 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

    OKM7f68``IG6Q(?q06%eqLvy&Q}JAtHG3h&YWQ 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_bfs_step6.png b/en/chapter_graph/graph_traversal.assets/graph_bfs_step6.png new file mode 100644 index 0000000000000000000000000000000000000000..762b6456edc4478e5888d21fa08190142dcaf0b3 GIT binary patch literal 36265 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≀h)r|hfqwZha{yoMHVXGmOB7~b+RcCdblzU7~%JHW5}w)dOq{T03L}9CE!0AqUI<*CR2^Jdqm5U5{_Cr;3RyyJ-xfU* z4{uku2d;76E06^@sj(8&?G>rOC38r`ZP4p%(Pe-7wq(5M-MNrNNT#S$E67Vsq8q8@ zEx>{IcgQ8k4%_@mL>G*}{VBr8K;Vn+mMH+g1|DAmk8H!+gkb%62(UH8&IBJ*)NyRm z3mm3Z8G`uz#K*3Tc!~R&15!yHelR~tkTr(|_s+;g_W<}K_gcuX3r!#*alVH?JRZZ? z;4@M6Kp`d`24?|$^N8;`@Xuz{k6;l>$x^&2RyKz1S?NU4YqFB(kEt~fxX+^!+Ou*C zNhb>gV`=!X;0-3_U$YakAn_t!IeNVN>g#H3`D;l@q$$=`j6y9>o|n&c?~Y1akH#_y zqU4KzZ8-aag^(uprvX$w^g*Y;z-<`JOaNFcqiz5`+0W9=-;?=;@XOqQncx@iVp+OK zkP@Ra8eATC$WeGo+<R?8Q^c503YH3q#lN%0X&q4Am^yZ0Z;;RK(7lL(cmNA3 z3ydR>>T6K!#vZFv;P;W!_}5^BaQIC$fXBvc7(!dG!=N(STCWDM4!;I~2Z$Ys09vn9 zwd^wNB@5vG%q~UGGJsQ*w@_r4Ch1{$?F1kkJb>sa@DZ%9asV?12k?r6bm$((rW}as zt;VK6EP#eW#8*ays*6Ff`O@@7XbK^T1~By6c=eXfKq8>h|G=&rN&r10*l8@_R}cXV zEG#T|anyRHs-xJs1=(L*T%@bj#l@hUTHV-Kr6B|m5tFMlE5;Mk7o}%(fE5>+5*?gh z2Z+oV_xX#^8H59P#le54PrA|F25}Q^#IpQE0CPsrtBdhrAKvwV;?xwt&|6agAsp}H zZ`+{Ae}Om#N&p+>pFr-xKGR=^WwlaONPgGFeC#W;wVb%3U0uX<&Pz__Kbk&>PX_r< zf@C5N;1vh|S?)CAi0OP|qDyoo9>5AWj`sq&>BiQQWXB-F%QrHBaB38A>q9hvKu^Qu z_b@1K-9@|yN&w3d3qgC)=)*b+;A5}XJC38)D^`uwo8%FPRC4jIqBjyw$A@LcY^-5EnjI4VUTpX2*v+jc8^ZL0te8B&I#aWontMU_H?lPTW8u_8ynTM`l0S0IDl4c7eKgK zpRYWc4go-M%{>s_-RXcB|C|Rb$N;9M=ld#%>umLcKw3<0Sc|3uDb4&VTQxHZ7`?18Bv50Zfb314wkZ!W``KSq88~`^fBV zx>czOH~vHa0*T+p0kpya%oYxI`K$u?d{!e*2U}>UbfzPK-5M#Z?ANaIXMmPCfZ4*q zE}vBZZ)hY}y!s`e1;nw%?b_NZO(?0Yt-T%F(mlIhRet}5n5Fj_6S}{uGWW~mO?@hU zyuL`hs{Nb;Xz8j3aPwsQcpF#@2hbL@^PYg~WvFyIvS`y1W}OC4i@cnyrK<|@s;yHa zEw?Q7nMT?^b4um_zH$eer*9nW@>vD&7tK%~c=nSTz%jaUyG0XbpK3z$a~Z(6XHLZr_2T}hpZ+~m!U43x z0n8R(IN0U03Sc65Ev3dbFu$m%kS=qIii&i)VO-sc9*y{;0i4bCRLDdsYPFAC=K%gs zoWSgf184`90sL%8i>bfiR8N7Q8(TTr32MSS3ZR^QNMo~8LH84`aR4oF0JFs3?A<|Y zn_w8g@h9-SFDNBQV~7_IMo|{f2wMjh3At=#p(A019^6iIw`>%8FZ5P&7`g3B>`V2d z>@_vMW@>lo+Soon2t4citl8<0iA~3VJUz~uq#q};fYksxTzJ$O{&YE?@H~h{?HGo6DBb5Ps&xNEufIqtV+l%KE!28gB z;AaoWKH%(Laef&XRRS3D9XB$7U%1d=f3vypnF&9{u6U5AiuUr@w0UVXX_=y#Y01o79 z<{iBW7xa8#LN9@vQ30Pj>fgR-3SfH6Uw4^cPKuxF8*|~O7>VJOsBiS`yrzI?URN8p79+^mPs~k+g`s#D_)qG zSpcPz8&=~pFPx_oKtjk<uRr~Pj+^W^bR#4FURu=V1#j{X#whTXd;*CC$tE8Ii7m}0Zi28(5$+nt_MH}dCpoBK-=qq z(D%+NLsSajfgdh9V$!a|&|G=d=oq9!D;zHzrM#0EvnAqKmCKUtje}FI_&$pG zhb+usMxSmcq;(!HfaiSm`@H|(0@%SsH4G&}r!tfSh=x0!iOIrXh@M&#KqbKIQFc@i z33EM+OFKG-?g$;Fx}2>n<{>7ZPQQA4kj=iy3v#emKftt$iqoE6n0Om^|gtQE2`-Vd; z1>G1ic9vRYP)h-f?;>WS+3Uq<*96eTK0sI0D_U+00Mx{^LvLrN3ox82aycjeP#kG! zgXe=o0VJe#S`$DBEq4*Reo!-1131Tx)0zNUr~&lRfxfeG42KIuZ(0sughtZAv(j>* zgE0v5hyqARYqckUeqdO>;ayjUngAZ4nF#%w0G=TOxG7)M&GA5kKn76o5z*_{Ek|gA zusxzHKtfuqJpnu&j}P4O)UFu-Qg3)%4q${f8hUN`6GhA9n2E1c4ZeqG%Qw!M!kR8OcuK zTC5^M7Sn=-*tQlS@+Wgn5tqkf!$t|_W>^BrygcuoJb1Nnk0xC4m2_^$f zd3m|Bv(vHlbZ~I+;o)I%adC2TvbVQaS65e3QqtDewz#-BGc$8|c=%&w{pjeZw6t_x zU7ehqTtY&^!NEaIO-)NnOF==ww{PDPhc0q+b7Nv++}+((R8*>}s>{mC3=9n7dUs7s zOw!ZSH8nNW)YQz)%}-BH+uGWk>oTmYtO^SY)6&ug1_s{0e?K=j_u<2b$?Zu+MMWPU zpPikZii!#-6nb}e7aSby>gsB5Z{OYBot&IJF)FJ4#jGUdFZJ4dEnXX=4UG?(vI=?yJJ>MPs zJ@#^xj+Jn!jmer$2DE&0DRCCm`lVJp5#AAYczH0hJM-RtCb%`|_Wtqq@9og~(C?Ei zyF%MfpFWA{j|Ze|R!&yrS1unN9i{cB?(gp#85vD2Tz(2#_9%D1yt_0nT}kUqjcYDFd*}NH=*(hsR zHFlp>NSkPct)&+&1t!nub>yZE?tZKN+C6#}`F){iuxRh(etq-z)clrP-A47uYB+4$ ztzs^-H?y#Azhv^zu5z`x_qgR(OZ)O!-srw<@hna7=q2>3`S-46qk`#>q~M}~m8S9adRTu@ZlF(I+Y&LCHvojT%S%aUxGx@d`oGi!0L^~< zN%Rx^@AUugFm^i_N0g*S&feAMu_XKkqd`Uih36sB6O8*2Sg~k>PYBK~K>rWwMrO;u zSWwP=-gMwL*CFk?sD!*57v^Pu@Lt@OS#2TZ4sE^d&&Ym`M=`q#7Kht$=8W|#VC$BS z9EH!Hsr_q6$g6hc&CM^4xXj3yo13|*b~)@MJkt{KIU#Qq$%+&!o0q!~h{Peu$AM9g z^qEuf={9BdJvLL$zTZ~+=DmbsI+&QQN&7aMIga&SWd}>UgPo7j(YuAr3egriY&T_a zP_2lA&Ys&=A6E*ms$-t{h=ZI?$68nKYEnx!|431TPIu|SOaM;p#Kdm=X1|^|nJ3$m~PQ;|ngg&&xZpkp>@P@ad zn{C0jNvxMi;N930B>-c~$cw&*@>2&v7aMz0vH~Hv#SYw+5Gg}7Y;hp3vgCaw6_B{BIL~O52T=I%AX}B%mf=m~)fu>M2N~F3 zD(Cu~@F+1zv9N{Sx80I&}KXjwTKMf-{uSWXcxaVUw(i}qd!+~ z|M2s}vvb90)z$p(ar)nuZ+hb>l$NXuQ^L2rgZ%O7K6W&p@?#k1v0}*gtu&qO16tWV zq7#OAun_fw_mYE1TzLY4lMyNVuExZAn~mk#CL*_ZCt2d1;u}Kc+Ho!Zvv1C(e)gu< zZ=$`DZjeJni|2!~KiRqC!gPsMzHM$ikFl}(q?@WuL5N7#$0v z#XweskrWS?O`oLVm)KaP@TmQbtGq|)7m5B z19CyKG|D9ttIDhS^QD33{Sh7~tL6$g4OgQtOaXN!FTLQHd2Tjk4^!|ACz zk_o5L=R0iCqoYBL$mRNt9pvjIf|nfH+P+JYS{JdQ4}9aO%4*ZGQq1jg7xGOOLG$*w@l%z<{wM% z=dG8pSfCRXpo}IN1lt6Cx5$##zKDjVpCxmqPJ@{t8s-1iw#;V z(7mo&y>71gXe3)wH=k)+3~(qcD#*!DjI5v@7&Wm#)d*n)zuK?FJ4v~xzJ7c#Ftdw| zj@PuPTiU$Fyl=>XHuSn=k565HZ)>r1q7CZ;9uQSpxp>!aHA4chdFV|^zlBJMu)i+~ zkfcn+1v(K>dGC5^%1}8q_Fd!nH?2T$wGaFhk z+>QBI+m~uR8quwzV+^dZ-5`m&7D0+&DscC!gz56J@~EeEm=!NpTT;6Mu|1oL&mt!< zaaY{ox6s)$nk7y-6i#ij@=Yn&DzV@YS`b4{LF#rm`I&_~Ypimi9ziGAYDrbXkkWg~ zzqvwoVxUT`aYm3-MP?BP`d2tn##8l_k@1qVb#E&f>z)DAYTKH!{(j!*WTL-Kl`uPU z)$i`yPz+h3)SQ$DKV8J&uUv0MVRItxcyC6w8Jt{!eQWo}rTV4rS-61AHza@6}u( zYI+~X*~7Zw60NKQ5^Y>M=j!+B)ew(ou{z%b_TDdZ?q*%DMx6#*`XGM<(~=34K~#O0 zktiGRIPB{d^||Uu#_MS_%KYH*H>pf(;>n}iKB+SeG3k?9F^oOXWwYETE!g8p+9Bf@ zPub{Slha%2?TG^C1*0>B*aSe{5@SF}Ka`1tmMPMbB>go==c>5=Eg$fdUXMa!VtQQN z>ygw+p6G5}`GFH-OlfFY*v@S!0Glj_h@M^J45^O#&8=esefSCRjk2Ae`XU^OUt7;=8MCOzQqRW$-&>)5<)3 z9QX39U6mGGl4h4I6BTyU4Gd_t9dkZr~fzT*59AXRYm~TuOFK}}ahf;zsKm!sQOSb1x zl8OcPizvphImVN($RCm27}ns<#i}V0U<3{fS>mU|3yPLl^hfukAmSOfo1iDbyTy=g zxP>tIZ0tT$xN(F)RbhBMfwyoF~X#Jx8D6MQKF8gGD0O#Ayg-&WMAB zK?HaM{9RtmY<3=Qy3Rn%l{)UTy`6RWS7CXnYNS^Id-K5M5D+F+;C|Aj1BXVFhbfUO z-kqef#MgkHNcTcl4|K%A!OlZ?AY#XnhVQ}SLFHxb{(xPQnuEF=ha}oZ;U}32v?7Z^ z#GzF&Rvm%|L|SY80N-Uhfdkm@gRyEr>IlipvT{iZJz%4wL_*DW*ctf%jaCy(uP?Q@$d!67y>pQ2me z_v$>Lhe^>onsLX^@W34$1(qbnO0j;9{BClPVjL{=3KHH>jiT)k58#EuVv!tb9~y}c=md!lqM_+i^`SlnNwL!}Gfu1nE=#(YxlwtOrb_3O)!(>Sd}8Q>Fu zdN$=yRo*hElf{bRiN_)%k9KFEJ?D`ZB6{Qky(x0tJlWL@xS?Bai@WYXrj+;|$yk7> z8gzX*;3+^B%&JEliwt%~cZpIvhMT|>Iu(IKn~qBTn8+S02j6Mko$`ZQ~P9?e_j||#`WoWy)m5~t$-1TkX(eTw2+(sJWM_D zkau$TNsQKMT3zNv=zxprV z7nv}BNmu4v|9-OSd1nne>*xM9-Sf3kyIt($4-g+Crvu8LCiTh;W(E5^p#d3$#C7j> zZMO1?3Zn2m{ImEQ18CU^xvh@a-;7<7u_$GX+(c6|n$+!nk!hE+YH5W`=0ZktA}f)I zO=?BvAC9=oizoL+gcBm;mp(+;^X!w|yItG??B|r3J(4 z;Ayb3a@e2iUt(8D0*>o#cHCLd!fVeKJE3i(JlDZ{LM%JkkFT!PDW$$%e1E#W26Vz* zdWNy#wM*4IE0pONZ$v(Y^qnFXe&*sIJKAu4Td@K2TcEw6svfx_qGf#kWHeTEWSguO z^vxz$Taic=`~9quIo4^X|AqCm@;WuV6+aveDSmep$(ms&Z=9V&a~kQ67Gvm{OGAcF zGW-26V5A!E>HT3SOIXK(CcX$tR8cr%h@^9AN7liW=if`u$0y4sB;qp!%!K`&p77a$km9H zV+aI|MCU(oZu&eRl7|5xiPn^xShlyucS%}}*coXMgr9@L77sg!l#U5UH#QI2^^L0H z-o))?Lc8jOkj4oXF zOAfvsDW0k4_`bx%HzX{|ufepS0;IFaaLR|GxMFN8U4l0_D z3aU{%#uomiW03_PNT(guxzP8!vv!gAQvG50G}@~qCROz*d4}0NjX7QhX18iJKF@9Z z4Xo>gA{vUl;L+3LhP8(qziw(UL1^Re;fZp5xFla*hpNKuum$)LT)^w7KJ&gMqTj|c z=116uU7QfTY>0I}^-(1T!sF$|8Xdk=b{E;Q^bfgY*>VkVu4F*oxvC-zHA15vxIGbD z8clE5lhKpC+FH*xVIq@$pLT^sBpXv4R`H`}dNf^71@NK^1q``jJ(>#obKPs0K4ji#5B=11^>hk6d0)c z%)co57q-wO$|angNhp9(whtLVPn(cJD_-@#pdooY2ap9>ZJ0Z_{n zu6e2+!V?|n4o^6Q2&_03-jb@jZ0HW2>?}TEvgstvO8?-PLo{$+m1$}&KQ5E7aed

    G~QCVIC7?W8A56U6(r|Ky@@paQ)>*4SFtKlJnpQYSCI$)$= z%_wB9&Mdk@0Q8nxgFT+p$Ac)0zm|RL#%;PQ&7?`QoGI3JSuh*C1zIRnaYMu8%8gE!!b#td{ zJY*YvgfwZ+&Ugy#3MR7(Kf(nZxlCEY-mN4!jeS>mjJdvY zVd8~{{5ntUU4cxIO4rndebH4fDz^gSP-x~v;7N~8;utl{l)ZJUFtHuC@!E$SmZmxq z?QB^CTmEvEf7Q5h21r@GHapqt6;mn953Aj~_!cLCQ$=VM#X}`@P8NU#NsUPUg#j6P z?XP`d$*?4IO)Ny10CYQx^`u053}jU*hUOG{q`s<}ibEKTU)Y<64jQlSDg@H=s++6N zG@B%Sdka9>`?T*l=bCM|6vaPqPKj1d?ORVa5mu5+M?&ZNHDA5*qGlIyCnLpkCF&Wl zU$+CF-ts!7zL3hMe%M4o0t+)8DZz~g(xJfwxcqhjdj3jJ2;i`wtzCr)hPeWfeLR)C zb75GJl2EEz?f^GT2pqp&$!q9E#>qd5_mcU(a51i5eC6038yn*g*0tQ@b4t1+Fkt0` z+Be%HUXS`8pERrFMQWovr0)Xq2zw$e^5bjk)52M=qpO@nK z4hkjBp!nPQZvO#)O1X$gj&)f(kX|^{emAKX|9=XA#A6R&{U&XL9V4Bd8esoIMLDt=r>Gg$5NbrAb{SzhWu%MuC#!Q>h@-S4*hc~lz$;5 zI!Fi@3~R=6?L+qC7g?I)@P+4uA&b*Z`SPG_tZW-N#Q>h(0XGTs1?c5ZTPbWK^w9vST;p>Ve&1!gsL^@bhRa&-Cj0WwuL*)|xwU zjIYX9e*D({mZn~&$juK->VAfC0e>GG6sl_sG}jkIelchFjlQbv8FPdc;j zGQJKX18^xy#5D=eQe-6s&-^oE!NoLrNy`s~E#?!sT225_D)yRdEodekS{#%MHwFOF zORx~^n+P~+xCNpfx*rp`na?&@hq)YN{pJ~b&gynRgF67fHY%|YXL6yRy8~ux-Cd(1P~RwD8L{eCv3?T5v3QW|A(AZxH0#`p%x=~>J2`PX@q2*W_Dg-mlhmkQ= zM&$5iAzYXJps-;ahiuM_d9d)fl?mD=mV3+ ztpleDc0BIqyQJ29*SnuchuB=y2HCx=UrrRRS1@*&&OQ{UjC9a|v;7nH0?)$xwWY}L zOeQnb6hA+eXghm3cAew7$zNOPQ-;4}!S4*afalOt%flyGOh`}~_9khtl}ed_?N|}T z?8BF`HT`o@6qH{V6B_~H`TE7y9S4H(DeygwQrTw41+)tvekNeA|Jpt0M4}cUkiH|F zvWk#BI{nk3=#|%w1;Gt1W}x;UN)>fRU~JfO1_^)|zzlGT3;+Ym6DmRca0fZ`(9DSH zBX*fhI=@Zu>t_SiBLWG9)q>++xN*b?J?_%h{uup6FY{6mUzFwE;)+Df=X$xoy~+HQaduDWb!&<>;(P)KmsUCSRp%?*r59 zM~b$Ak*jBCcC1wV{sM1r1$|4>$g?60M)49fY9eGP2M=?S;)1|-==W~AwIM|q8*2## zS9if7SEvB9Au*qg2UY?rClCyR;%!n!Tk%Q?^+o7{&v{x9otskGfjjo?>Q@&b0@sdR zFTT!48AC}?Ya)4?snHuUNHr z*sn(3fho(e%(_`;M~9p9`KWyH4zoO0d7M^vhcQ5)P5KsG?lolXXwqXHWGyGu(XsXm zj~w$M$`AXJ+TPb<6WZ}yExg@4BN!@RulrH=?<7jk#_Qc*q9yO!XY=iG%3{j9YOf2L zzkL#-{?<7N5`SJ+@u1hFoRDGZu0^B{1+}tUa!i~Hm4W0;fKbGB&dE31Tf=I{IAuP* zuJ{G~fIRwo-Q^~Z{i{SZUAUMYpnQ7SQ>rBGkC1{b5JwCv9k9E|lf4VeB%P};w>%&=H99W_A;rAHiRUVJdwCB=ZXjI-7hOo#i;8$^^b#1(HOYU*~YVH(WH5CiFqdySJs^2MABrek1ZhZ z6>B|^qb-*}mGyZRu!E<91u`~S^KH!nt)YHH2NOd~y1oMJlC_A&bf>_dK%LrDzWPrX zFit0=N};*P54G*n&M(8HMmV8lj*;9qpAYrmDjAM}Kf@RQmqjH1{py!mrzz)1#C6k7 ztv@TRO>C{XGwNHbq)-ZOq*D#uRB5uk!8U$C!~}EwVd4lO#k}riVs1U;kOnJFdom0d zm9%bZR?yDd1}jTl{6A%&TSzM?!)lZ8$k3DPMfuZbVe^W)sU_x{q3V%q>z~_9HHqTY z_PIw)ORa)qPs4-qU$}@{rOD8nR~!(jGgT@IDa@Ic(l_6CKX}#hT%3MyyFjwv3fsC> z-Q1yErs)4!{u$p?$&Rkq&_;N=c3e`Ci71RYkPz#U_p?*bQ_c_jAarJp0!29<53Ur2 zaT8rsLv#*&?`z}IH;OR#7)aOrdV$N@lq!+PU|Y@Vo{HT537kjrtDWB>KDUpnCo4Z= zepzO9G6UUQZ>9RV%FUMq62B%%=lb_>JE;7Dzzr8zB`8bbjWflNhwI6({WWLsD17(o z9rLb`4$7QAIS-rmT(v{^8haWQDC4AynRpYD9M5O+U@>C^o{@LP z@lTQhi*kH}td8dTihlGK=*XT|*}}CnC_H$GR%*Mu6%hMVf&u@33c#gNPx|O@J^QNT zc-Lin$w+N}SPj|Ph!jS@y+=DF;z4vG7ohG&7orzbk5K0wBypsi7!M;%994LwXK~z1 z{N$2wk5&&XK+$>U8$;^#^D2v!0_an^e(~iZ*r?2nv4&LatBRvKM|S1#;1CCqyfcfI zj|!!3M2a)+9apc3luC0G_~V3H8*{{&=!XM;^Wsmq&~T2|e}vhZ8<_f%!(V@&U9Rh0 zRIbgeNmUH8cuX#&8E_TaG%N>^Sa9LQ#iF^{LQ49dF+S}sFMoe7Qcbd5bFB7g!k#0G zxp@)6j*Y`n{G$Cv&%*mjOJ&LLCm9#7$WQU-R|5r#aD?u-U0iS>U;P1p$kBGHwLsEsBv>k&UgaAftnV_Ff0<>)LgzK6 zwoyb}5psz^c?e*O*9FNuNhfdBllKtHm=rX!sH}S782B^cPfM^oo^FqWZ{#494{>vKkIE!j&$RQs`}kj*26E97tR4kJI*GJx}~T z^cf08qFaEg@S?z61TQ0Q!dfJUZ+yNX44}j1SMQ{PUa?zfNfc0jDEXx?<&E6jm|y*_ zou$)V^35qB;ixu+qah8<$k*0Ib^Lk zu0>Tb-Kjhb5y00Cfq#4-}k@QvWFuOrwYrX-&VX<_KFd^i@UDS7DkZZtLwrB{cE19FEF@{t$3fp*vt_$II0L>j9Jzk6tUaQJlA^ayg zGW1g`_UOUwHrm-8KK?>GkFk<|pC(u;+it@9@k}JEf9#qQB9I{B_w0LeyyC?G^;&ob z1l{XkGsE)2c4n+*H|jXV#R=5evOEn9*kL|rbE_U@I2^FI9tLYdu|!nFjIMG}8$vd? z2)!zV+r7UP1vD@cD8EkjH6u(A$4Fiu3R(j{a8-j3Bm9Olvz>GnCKTn? zIJ6KOD5r3uIR!DJ4>sqLQli}tE_6X%o~(9dw>^1in4KxWyXJin31VGiW6gD?fvK)} zJ(d~5r~HyRE!-d8JkO(s@qR4wu?pi)`KloWnm;AocD)PLg|h1aq(I#}&~cdJ=*?qL zE4Vu!>j)%s$^u~=qg)5)qDXCeK^+IxvAm!^QXeRdVHD64SvM?fO0>7iis5w?as48z z&9x*LTnS)N#;riKaiJ@Y1%x2AaaEA-4^Pthu%r=XHd1R8E?FR@sdwCJ4$aYI40B!dr?OJP!p=+9=P*B&nXUgixeZ}L@#}1nJMTgk79j5MNwmh z;2LQ%Kw`v=UNd4sKdQ?U;E3+B8%}DhZd=hf205I-ksF~_f-C26jPu^We@uD$ zm`BEu`V$x1R2p5HorGvYiBVSx)Kv#&TgljG$h9-=M!5ZT14#+PB$0tYPXug&?St#G zXSIl`8eFb`EKgK@)=%#AurJ#);!6ymNp4s?@4QISX^BQ^yD@7&tamhSdaYZph#YJh zq61JjSTGS{==*@0Aq$glhg7){+b{lp0ZuQB?hfTJ{g=S#V{ID4j`i#u(cfMp^TTk! zqQzqTf3Ruk<)B^!s?Ho_Tew_GRE`r`Njk&FqQ#YR?|yOlH$+P1`3Ej)PZ&iR-WxkJ z#L7ybE;t_lp)%7H>V8u3#-(n1u9!(Z81g*YUDtSWpjsqu7e5L_#!gd3aeRJY26Zjq zi95VJg}($Pdm6J(Q=FEBG)d+44qCjg4|x=41%cGDN-g+A)}sJh)iFr&7f~HJF^7_p zP4S~9Yj?u?!F>)CYyp*Rsx^D~oBI~SbTnV=fIYO@sXw^_8z?y zY^$o-NMnjCpKPvm1)9Upyj%akpL>k8wzINrD9fg?d zoKB5q76)ASB}&Auzgixg;r9%Hc7bw!Hd zcPR63L2}W)#EOjckw51Z96G zIyiY6RAFT}u#i4b|N1=LRcyBl9Z_q*39rnB(Itcxl8>#-nyw^W@@LLyf6MG5dj_7U z5im;u(Whke&71QQDMPF3l;u#8J#{0khQOzEY-us{xrH;_+1&`#-4Fe%BnLtm@E>oP z(t5ght7n%NFoeI4=lniK4Y0ySe)Z~=`XqG$Wc&w+X5y5z72sFx;#I@pfsZn?w=BDL z_&&l!lk?tpd#x$msK$^f3TGmRbK`3)9nm|H;tIJI=V!41|&bD%j5YD1{Qg#AE*Zq@C|OBkb~$O!RXM zH0N&ajVFm?3p^VLKgll$he<`1jC^KG%BbX5t2YJ~g^sNXWCDRpREg6e2QADToYb40 zX_D&K_QYt_J#QPLf012>D$gbtO1Y`)nE$gca)Ql<`xb@aXu{E!7|c(91oUui_EPaa zMWp@)R`r#f-kc7R&gsH^*rrmk&dA0?ZL16}^?hJP5_l$&87Vc9X%sUh-eXviZn!PW z8B1#)Qgycc8l_Efl%!++uy9xLu?Gu}yIaKOH4Ym#1zw>PQKMFh)&}F@Y-yG8w(|PN zYm1=camV3HzXh55MD2Hk|4e#A%8SY?A}cj!-BlVT*N*A`dwHevinew`xy<0~54>2P zfl^wLo>1E`ty+w_cL};`gIvDO zefA3?3l?k(&HmbBFy~bFOx{>|$s1vqi-e(?)&Af$=_rvvhv>eiTvnAGL^JVLpUD&X z{9@haXu9+@6yyej@~ zE=j%DP5EC!B7Y>v8+Hs=@e@LWK9=%&KCjavou4q9-Af_9nY8Taf`$Ye6Hh;SNjP*NCShhpEQ*M>A_e|T?E&4)MI z*q?KXr~QhKgtHXO+PPy}xdFW2CNsx~tK@##MztOE@eFWe10LDHj_!Qo?WV;27v7CG zbn7UwmwAaLFV*ZLAw&pG#9QYw8u9z(Ko&e2y|tD1m03QA4}qS5KrPC$+_zwf7q#B6cCvpg`bz9ZcS#V3 z0)0=rXTa)J%JAiNn9;i)P1`^p;-2~bQ@xm|Jq#}I(MQ{DSKBG~_A1uRVv?Y5W_cP8x4F*lxBPH6+k$GOQ>4=v ztN9%*!x}elC!#8BrRN{2S%j40zIA8CsreQr#HrT9uMAq_9*sE!XPwb z*W5tFVuf47=7!d;l|B5@JrCKuN08C4i^682ZA9gD4;OeaqDObAKouk&t{yT;HEnE8 zHTa=3t4`o>8pGqLaM||!0$Yrs^|G<-(L8{k2*MR&`u+KRfw(=ceQ^rIWtqmznDLk4 zxHXnl8=dWw@k!CYvPlx%rDZIw$4K21XOy+)1h$r2LSo>#Z^f?uLLk`T?XMrGN+Uo( zqplQsM;MALO9!&j5xQG7+sB(v!FzK1$%*V=s(OvTnWvbSX>Pa*dQK17VC=z9;5f|) z!?+1!y8S9G0%2G+8YL;Vn!d5cT^Pr{I$bJ`1dKlg8Y5USs?*reJ_OD^X4iK)(jn8VBnpY835D6{89^9+-1G&HQG0qGuhJAV{^)VbyeB z!LlY>{;Q>ByCY?ULx%Igen$vV8(u5~^znrJt0#d-MX_OivE#QELqhKm(o04ifg(m$ zqUXhut^r(Lxh}YOi*MrYfTsA{WzmB3?zvGk1T4fLBD9er-f0zb=gX5QBXMUC)?)elm;r&GW z7q2uNK;KwzPwc{dr%|9SUv$7h?8!mIfekiWkr6a_usVu-6VW5gBVFZ7!QeqpdlfD* zp+#W$1r3&2d%laX@-QXt`JrxQ6aJ9Y2)r=hZ!zOpa-Q^QTbE>crW)S$RHhOWaR5;n zzxlg;A!YRP)A zHb!`)(cZj-d>h{8viF?^HTRZ=e=nt2={Q>irwZGo5*JNC%s(+iiU+N#{ygG?i9a%H zXP>&AsH8U#T5zjPxjoTm@6+ z7xsW&pk~}%V3#oPYFPd2LDshR!ccp2wysAv=yQr~cBbKN@dun@m*Xb5C$s|ZP`4}> zn^7m5H{m4Iwenr6HMmGAMN)Fi-#VRMcBeF^UVR}e7Cigw;j~YZ-As|g*0d9Ed{fZ+ zZ8zqAu4D~@efcd5hzhP$ zujpP-4>`tj1+7jdBtzo-D;j*yu^r!%WLWlErOXe7T28$zAD-e>$cDOrLYL4mF8};8&{6cNMF92% zAyamz@3?8_J$6Td=t}!S34i}jjC|^>=X{kn;@O`SzHX>%*<_gSg)F+KIi0OuoNu5v z61+x`$WS+sJ`?tIGZ}cJ3UyHQpgPJFuKOcY=Pv~?{KCJas8-vHiOr2olD?msAF55? z@M%DFcPSRc`sYAz^uyW&7r4*#h~PMU-v`DVwBC1WM96kLLX*|-Km#A_FRb1HR0sW9t->j;r)4%zODXA!Qj=MO2J!&RE))Bf;ckc3z~r`k!FO<)!k{}1n!26 zG@It;K}#dL-~k%)pUY!5r`19ioRPcG%hd*B)GfYUn{%sY!P(hCD+oD<$OJj?i+msB zq8C1qt`q3bMv>$+?__4dU1|@>hPwUd37TGXd7tVCTQ6z6L`-IL0p!2clDbxFKW$8# zCU-gTAyoi}cw}8QasdmDmw2{1b5q4da{jYO0UIaUzkC$PSO21UMO3B;5oRb-`-$CS zGp_Qpb9}=1>cB(BqX0N=_aGG+wfe!KLgZ<)tYm$B#|`tVN%%tP{`+5EA`;1;>%lep z_N6GPMJfbA7{9$?Q>0%pzVPVl4xUge@A*_Da^h>A!1FsZ>+6};5L&LO%1gG`yK}>s z85oS8K=M2ct}F!VLw4isrHi5|_x1_}#};}8UOIT@LvK!?K8emwk=Oqjiqj)s0i~T* zQ~<{@|5OW&QAhlzOUNFH?P}$4pKI=1fQ>aV)9cAb$*4e-8EUdQ`7*ygHEgcJWsSlt ztY~Eo()@%@W2)gefv_3l$CV$N`>!l>m6~=aD)ZDW7T*i~%d0ASK=Hh(Q~`|3tdpZo zU73P@UBlLOQfE_ne?HbOFnY<=E%}o9Se=b5+ux*I3jbAf%i&tCT&u1cI=xz}WC28h zp7x~P z$&ZpVA04#nKA8)G8H>G+J%G#iL%oCD|6w%t#uD^Y-Y}d;muZB&v;Sv)9$Wa^QDYww z5!)j(-jt%3@~Q}M(HL5K*+l$jOKdM#?)FHkv#NeUMn1yEKY@q%&_!nyBOnjavg62H zcz@J5_oV~K8j~lUtK@e77ZVB_ucgY!#3K?-Zt^TZH@)+;!?%<2TvnD(# zFBWOaF^6|U3E(@R2zjd#>WMJr?zBH?keS5F~>A(DXXMHow&Q#+ChQH;tj z2DG^UVj~cR>TLtn8?#%({cKWeP$z$eHtN0O93miE z95qmX1|!p+m~zklx^}awa@ejI1M6lrSBK*wB+aiO~s*W+VP?at2!KvscksdW;pM96pMb7%oy8H0Jl_t;k#!n%lw zFj_xy$jM~~awn+NEcrZGIc8x;F`Zh3$&rr*)qPFG$53wfz=fYsEcfFEP-IUw*90nqYeQ;m3I-WpNq!HjnH&QB zP_O=&7q!@i7nFd|>Fwi>1$WV?Tr1JB>b(oGQxyd7nbZAbY-~38xlTcmL3Cf6JF5W~ zV}yMDQ;teMccMmQDYV;2s+KiKgo()oigYuFXMHrDF<`;y;6mi*z37<60 zpv#j81nX=Kl+?M+NpLru>ly>WkFz1`E$p`!=&Ku9KTp=E^$<`}{kXv-;XS>>Br#j@ ztlooB(ot945v$a2SJ;7PBa_Q5TuhClDE;>}G$rGqu3 zRv!@|TkmM)Edzp3C51(@&?o6Di}xQ_kj&WdEqtGUt?z${w=;x1E8W|obt>u)p~E(wMog-$137w8D!H{UhU}|zdBTHSF%dKFPXJ<16@namruua z@@)J2Q{H5!SY9_5xSIIApogVx4~`2|`NKEZKL@G@byAv$+2x7?!?{@`-z|oOFW}>+ zaq*(S{X~x^vtE>{Ll)HK!-sbW$kBY3@Pj-{O1!gAyKxY=_?_ts)At%}$tvJ+)G~Ux zi{91Nx(vX`W_+H9Kg7DgZ3XoY)|L-`y+!jSR^U>dVSM_EbX$*5TWa+>A8}no^4kK! z&GR3^A9M0eR{kmuz#os68L*o(9M`X!2CgIm{!pp;@lbI$8se`_Z{#eDv7ngNw~3KE zCzI6@$S=}&ZdfKd6S<@i3*b+XaXSLJGdWS%AY#nUnP5L7DP#$(JNwMG`x}!RgL+2~ z4LOo^%qf)c%@-SZE6t^4gg^&muu`dY<|*)ThQC4oYs}u$ z?}K39-HkD2(Ug1}JmGX)|MT4Ovm}VCoNO!+^~Qx*gnjH7#8V^sg&OTbXtb!TS9)$Jf7_ZY<~P zr~DAN24S-U3Z9 z#j0m@z16k6>g~wfu)F*?-c`SqaH_gBH?J4Bhw9lk=&e<90aO_?bB;71E)M>E(2xc~ zdWorkSHR=cw1i=63AJ~=K$S1r^F2D*g^j#{n})NPB%Y5@K4NCp`H6C@o<1BGL1~mu z+z{Es?uFs6A_exvJ@NzXh1+lgbMUH(bsEr5R2XQ8Sn*8?#froc!?UfGWLh9>APTXW zVWEOhBm112cpQdS%$rySys8~ z`A}12=`{PIH61DGIkm<0JlZ{gL{J2dmih_Qc3laKQmXrOqiJ_;y^(~;-}eHWYL&DG zcz@BLS&F%-1U_sS*dS5mAREQmnL~dRO;*7b?6?WCJ|%ikFu)C-HzQdmuIooyn<={@ zNFu;$P+!A-{FHYq*t<($lFA&$2(+1QzH&+ILRQt?e+f{RQS84Ih=^zq#DZnHqLSK- zPo;*0D+!8-ifTEdFC|X5JTMWA5?qTV@x1?Ln0ny?!;%;yB|FE5ugx%?g+riknLkSN zm%R8C*50os3+9lk?1Y@s;!Iee!v6^(bA039@SakHd_!8ww*yL9l^A#_;7upduE_bN zxCkl2ofsQw023jH1UV(1IXy@VQ{#kq#JnzioumX)G-1{(k^u9HDUks|PUK&^zk`UG z>fZw2bN#70Kp}J=rElSbG_o?R4`(uo-x=);+^9c}NYV46b2eU3(2~Ge_Q>|RrwC1S zg|%lEDdEwE2Y&CA@F`q@50o=8Z6y?8EIHb*(0h2lBmG7Zj*M9$uqP}*8cQw2KoQnQmvJ~(z5~yNlQzu@$T4Dsw>3O^SK3Osoa@t17 zybHmRG^q;I_KWi@nI^>jMR#5co;asFC$FP_v;@wgCk&ylYj`fM5&Dzcp!wY$w6_9p zA(BvUGNX5v4CE#1!vg?iX7)1b8uL%pK1FN)aX)3JD(LVBr9{e|qhqA}S|!tJ$%zII z(9qmKYBO`eCi@W;JSZ38OwZDI6$JRk>5|k%uY0Til_4*EBcds;2Syen*!P_Un?A`R2amb?TYP3(4M>@Csq>Y^g3R+Lp7@&RSSr zv6djE+=jv{40eD|GbjvH_`9->enfNHXQ}k-@c>}JG9jQah(~d&3@tJER}o)n{c`0>rTAMG0MMZ6d(bo{bn)h#UlvPzC;NR-ef_w+Elauqa& zH)p_!1c{gh&zqq(Zniyyr0lB*)KjvWLa&`i%9Xs99l7Tx+o7HTC__+vdWh_g(6VD3I$I-#d_nL1?g=!WE3{fV;CRD$-|x5-b1e`xkZ< z17+vFObK3ft|8a~!IS>reU(qbA z-2t7y?kM$Hdm&Zx=@n{104nuCT~NkhAL=m40ENf9WWf$3O7&N*-Ue3u@W?h?Ar82@ z!pL++$;&i{Z^$DWD;Po&`{UwV0S~|!-XyBfi|$MtM^-EX3blEN_h!hyS7rp~kEm@mZ!amJ*wjB`! z$FPkFfPI&11faX~@Gx3Cq?~({oKDCmd&n3TZ7SC*ZkS#6N;m%`q)>RCqfp2LC}>RI zE5NW1#$m#brvY7wEbjNO{ylXo#{)lQZ!RA3tjJ*Nr+18^?UHO^nIPAFPxp8~n|cca zXz-4J45q9|hn%(+1#Kzb6Y0qxO96n0)ur$Hn0ke^vg#>X#v8oR&vz7sDPL>=B${nC zLR3U(0$i~RH}uogBT`-cFB*2E80sGW(IdyHF648c6w2?rsC5g)+t`eyEBe6@rf!C{ zJb}aM?l)&8i&CCbmw}jda1==}xhP<@&y|nc#R{P{Yf3GV0p+mV?#h0tnix5|*XlOZ zEjsce_5S4eY@6wZ@!j91rQ~Y#M10TD$CfRfCv|@alR6;zkN9|S_IQ;2-`qw}qL%=r zuX_Uq?A1SP_<|&&qkpGPLtt8N!2lJJs|a`5b*@P$9)J0 zn*tDPBzfP!Iq{sl(_b(qJB57zTeErf;qze8?I5NH8W*F;k?q6B3HZ2dE4+m%!M&~yWQXMc?jMJzwy-fX=1rI zXO+oK4)DI?m1iK09P`dN1os9iEOGZ~N}fslN7Dasmu4qY;A5^# zlbxE=;G2J-%m-Kg|FC!&S{lFLC0Y`BSD+GG)NubEjgXE?i?)~s>&3v%{TmnNumj0g za@dSJwX}YKnbBW=z}KP$x#SZfhJtk9tC}_C)%WfjOg^?8G8#&98J%v-lxx-9pVpTR z!(qxBFCj8nR8O2E20~ZFb-en>CakSt&iI3Pgj*6z2-%#BVUeiMn)I5?e2rx^=?+y1 z2P=x?wOux(O89Wr4?Wke*aO8kOWzdSTT-WXPLNRIOgbLVivBhrcc3gD&DCQGJ_HUx zwq>+zOo%?veFa_UE9D}gP9^mXbN62Q2qz_Bm zCe6f{!B#D%)4o)y%>M_U&NIi=d{fYi{sP{(jap9m`E}=Q=8ku5VVxg~J&x(*vXa>M zY{}|yklqP~)5U1~fx>7%$DiJ3#mab*^DFF0VLB+Yk4i=2a%pdF{)z@QM`A#jMJ zxc|<}T*;kI=~Wew>U*OYsOq6+ibHBzkN!88O% zE)GX}bBDb8#UkXAoSkrzx& zv1u+<#UC9T5>1=uV?3oT+mEr}WmZo89+v@9i=_!BZjXG{yzo8>MD!`W{46qW6hS$m zCC!H`tH7v`fPJc_&ut6)g5Q)Fj9+=}l)o)kWG3i6?OT``Y)JcRp`lM1dHItr?#C>D zL^m*%S%!~2olg_q4&*JW#+n=HF`~9DY%iB4VPXnhtSZtkPj9osy}a3X#Nj)Uv9Bm+ zk{8lpzY?hFu+RqK zwr^S%C>%?x*!i)9>i>qbK*gby2;*Ph^*_4TGVD8?f(&XPyNBQ8^3C<;U=qdj~(ME@K6y`Z{w19H(K zubX&%Uc4JKMZ;Gm{Wv$`So`quq~seudDqt-Y=2PjHHqo*l@u&mP1g0E@7b=kfR!t6 zsX?)C`h{vM?(`>L(i_^YHv{g7E9k*P_vq(JN=nz=DlQx{26p)^k5s^*j1FOsfXq$5 z=Fc&$3BqS4Iejq46Y9V6cgih1XDKqYyRK13+1pfgA4QoxbRNwyH$Db{QU_V>5`Xfq ze=$YQukZ)>L#t>^S`gLMAE1e8l5ji18A?dGZX!DL{i3L;pLUM)DcukiIxW{f;8uqF zXUMCCU|dOwzKS-`?vAm>2n2hlfktDiwFPUatm7|>- z4MSL$zd}@cM#q9Zz~!1_+`<1`)qqx~(-ES?fR9-&+gJf}*oZ6n+CC3uDKF4zrGL-o zn;xw*$D5y&%dZ2OgD|9uI!TRziVt8IhjwUq7v?h~p7iJ1N|y&@;UqKzaA0{KD2M#B z2YBd42t7Xl<31Tw%w15Uy(c8X=-|1h^%}L~)u`4|C3?Wa-^hQa$IFe9 z;mM0G|AwxY@?l0f61Ym4GGVxd|% z1;Kj-rdH!O_x?nZ25-vI?T>oDvL_*@49g>qG|H5_jr`PskanTrO)HPu*Mfc4hIVL6 zcOszkm;7W_tB(BcLN1lWT!EFpvu6w{2rwxl*?$JQo4CBYxn$U8C{Jr{nd*8ArZ)9N z3NgdNpEDh%!uv&?f1umP%V|NWD-s%u^G#3;dxFVhn5HW_uy31`(rt8W-NuyN3j1au zJcF30N=N`vr8F2t3=byNde8aT=`&)xntZ<1_)U=` zB_|BoZGEL~u_Xptia4)IN=UfU{TI4Ukwmu zpJOpF0|^XK#vFiQ1pzvx;WTd%A-|M}k-l!lBDnG!F2?jb&=4!0}iV@UOumOmW zf2<7qAOyuRkgiDYs@Dg8{w@-6XBBSe8nqH|xtb=BG}~*qB!F{u{uf5J+}e^?y74Vu zlKy15og7A}$3dqV)iV97lyt5fF!+K|IS)h~JTKs&Ci2ei%b@hNr9cAi?wAei5C zq*$xs2)0=@@LCAhHicR%%%!5T^5A#Ps}HlRT*_`IARO9es7UsY+;CvriA%LtFBk`E z)M5j{QV%*}Slw0|9E9B_RSMOkio|~dl0*=L9C%-islv+*m?pu%>xiFsSG7wPwD5zY z6M*~5(&F-6jpSjNNFf&o+<7V**U`mtJa1XMp%Ol&DaHjv<;UCX?;KTBVc~zolU0vG zMpQ^gS&nlKS8hrj8&AM<=Z3hVg1nEyYJ*TAvTVI$CLH~qGK z8IbIWu>3SW<#TlA(^V>Ec9{*NPd_ZkvcCJe3gA)byJSrV#|TNzVej0>8az-!VH>YZ z_)y^n#nMR-57^GSbX>0yiigOdy%XV(A#VP6Qg&W*jb|@>F>8(LAu#IKO93|)`d#5b z4OBT3Ok)2{>R3ub#%mtJc7o8ChP*(~dfIG)@ygnP7iwAV1OxjD#T(n-zV#acZJIIu zJ?OM8zI+~=RED$Bi&OY0yg4gl!0hg#KPIJ0OT>TPQ4m6ih#ZGM*}lC$(HUs^$2dB3Fyo>c%t|l!MxcQFzDLn+uS5 zDc%^O=1?Jm-`Wk*sZ>GQHt68;F3FV-f2E)?pB;cOJD}*oqV~Tx)^%aS;dfa%K z`l&3-_pcvNCF84tVEM`(VPTjDqTE(Qt-$_S2sKoq|N9vtx-b*wPn@4!BVh?3naJn) z#`1hrlh4mmr#mJj(E>fe{AQtv zm>Bdv54_Q=Ko2+MdCb@ODqqbhM03wKn@Gg(jMacddRuKA=&l9H9UHvf_l9jd#26^} z!RzmQc_?OMqzvf5ar2qq4wo^FxK$%Nk1XsbXI<{kkN7mJ-%j~ z0Rf{K>kB&J$f}8m{1{e$b}|36L*vuMo0WuuY${TM0_%UM{H|{8NNS|_ zkCz66mE(3PM5VR`#J-F=Csi_7q?GnQc zH!MmrvV1{0 z!os`%co{A)`4w0m;+2Wd|U(J|nvF{L>nAW-H!)I~*UnLA3cGpB3?VdhE7N$BR0F zhqLAg^2t(C*%}6q5aYAp*<2)92!qS@V#pRh=M{>^FCgr04XR)?g4Tv<+f&F0cLhLM6VcS@gxj0f?dkS2Gn_Gjq zhJ5$Ni=}vjf;>*MxCe0jcbq`p$>;ESLaWR@@QT1rp|#|MpAzJnK-D3lrIfgiLZu@U zkj}{gIf@)Zf_-?`Bt?8rO6f}45nTbF^dPt(r#aw;BuVIyh2Im=My8F(s+TD z9-qdogCE@58f4X`x?w}e4DdkQoVB>G5XTykgINt=TyO4H?d7|vi_}$(Nf|@#?kdWw zH|AuZ##ZI;u^Ho$+YaOcppN%dFnL6lFmY$T^{a^0H-{KWGRGd7(rT;E13;BU--l5U z#@BL$pr|1ivg#K-GMb>w|c9!VY4^6BG;>w)n2iA@GsVj#@ zy=GCG6RI6}tD~&yHbjY?Ffwv6I@X|gp9n5dm?u8k4V z*fHlPG1EZ$qvptq2h;5&5TNK>caRx>k-@XQ2-K!w)>j|LEZG zRK3OzA5Y!p2y7}QI+n<9{L2md+Ztcg@Jn4C2*%xm8toK=DxdT;u)Ikp+eyM2)=ux#ZV}vgW&# zu2)ESk9Y_#@1f5eyf>AKz#m+Yq+2^!zbo*+0_Y(f94!&B#RVz&BjE+1t;OaFw7QW- z6_mqr>p}foZ+Fms%d=ol{#!42~pv_phg`n8CNetrY>v7%)P}-v2P2323t$pOzZ{tUwh=^$@qL5fhhcT`i;6! zJ-dGd!ncMn!11BujG>fBbu3?a{}Hp&-v?wcEii^RsrJ8q7UPorSJ5~-A(vboweAE% z;sx(!ZQ>$%ghWODyJlDN_Wm$aGFPQb&iN18&QxwaQXSj{4wdSaf5XoUCIxwGoegrr z<39EZC9Dzu<&#+H>EdFR{A}LURbjpz=38mFiAw`9^dyw@ z&#od0;Qx zRl5{IQvFwCpp7n6DrD(4`9ELTJ)MJ_2~m{*2DtI&N2vxkXLhWO>tHTt66^{QB^RtT zY|G}hSLPYbGg0EQm0OSxm-$KGGfcnybfz_s=d?znXC*?Cb4nsb>coHR{26+S)`@<` z;BEa<;@^tcN^_AtZVt_+<6-ErOHasst-$3K9e)0)Sn3<4mrQzw(rg>blMYv6Yu)-} z-9jS-KQl@0zkoDBS>StRSSU?9=Bc1@=9clP#D%XLYwe8lhB8&b%y$$?k9~~bC)o$> zAIKG78 zt`VyvGAz(o#d1&n!z_omkVRwm#0h-0BX>kZ>Co$nr(zUJT4m{L2FSA(Zs4i`6k6AR zqPXleG#A`Mc)eB=p5OJLyy~E4Ic}Rn06px~e0KA- zhOd-w4bPU8R!@VL9akD4$QLOr!E7zRGr*$|7{7kHLIHym+~H2((5H872uX~!CHjpx zHuwQ=%R#T;Yg-;o5}{=0CQF=cc9$75hOB3GMR~-_pW~4&g!Y;&P$8=)6VKi0q>%Z zvwHlvP{08HBr6YcbVfy%@h#V$B9c$fCo!j_mGcq6;XBm%YlG>rKl6R(&7dqIKClov z-(iB|oW<*ep%ZO+C;L|VXO$aIwX3V1@%Evd3Ik&J!cGG(pVP;T<3m&0xRK-X#4LZn z2f^kHvuy&4WSSCfeAV<~)PPq|{553V$>}Oip-0<5eQOZvrgF*r-5cB4A@~8CZRTi= zY9?5a8*1*(x6Ol)#g3noIkU8J?pVuLY^!#r#O(XH-$n%IbU zCL)-1&4RrF!0!8gxfnj26Px)g6~;%jEvG)|( zA!zz=a?p?2Dg2TXMzZNk{)K*f3f?x?K(iP5f+gru)}=nR6F+8~3Z(SZhc}rMsqIv6 zbZ?1r8HmK()Ry2}V7Jj*0~*z?g5fE^9s`PW?!ouNp z4VbyQ4YYCe__HD0`RU0TKB%Jnd5=5a-gE{tY0bQf9UAaKPCT8IVlpb>o?mF}2eY4q zT9#Q;{T;Df*0;h{_?Ks5^hwzis(CoT1W_}u$auz}0axs#_8`ThmBeZ+rLa;Z#Xrc+ z$HRU@kN7e$VG2L9t(w3%<(JI#NHHM-gUV)f}`e zp-~R5V)(|Z_i4L>9bwa@hH3j5n<$D`9zjR4c8NZ=m{R*A0)n_Xe%G_ci)YTlj}-#B zUPW>$3#a4npJ%ZG28~QI4G+SfP6AaVRo(qUpw^KJDMXk(2R zs-77O3GMb&HAa$G(Ke3uKbyN>F3SU1$~o=35uHdX9l9Z7K&zv{#!ns8dtdqyVc`A* zY*C1FmKh(%dwGwCbe;0%khm92>EODYWL--9o7`z^`C&7 zqeH=Yza#1?7+%rEMVl!+D4Ah_zZNJmfG3l{qCT49TAPBJcsa zxw{1kakMdySRWPMA-%p9Eepwi$@*b8y=|7%ajO-n;4_*|dno-$YoY>8+x(rRS8R!j z0_TA8=dR^0rpNd%+#oZ@zaP2hsB{4>Nv}3(ld`|FR56C|OI?TXOG}b~cn2=oOI^L` zD}@i2%BDs08MYhs>Bvs;^}oaF@@lQ~GKfgtGLN{*x;{^vHcWdrJ*_@SsOVf?`0#|D zVay_3zeL`RACMbVMSw@Yh9Ub;>}q2b14W;Nt#5@u1H3)bS?nALYWrPaJ+Eier(!VG z$y)%e(GI3ON(6%^+7isGjh4GE^=9xF^|gSO1Jr{`J(((TdoRKE!>Tv$achTrLvz#8 zR=IxMc%-X$6Q>w70WvWdr`5aR{U;~aG$gbFZ5?A5GX+4yTx*9XBZ6+6h%7~z`0 zW5`XGC?0IZu?BYxDZ`REDq0BiNC=7&DR3G3oX!aM78hcHMxxs3qka2A;`G1-LYW-M z`|w}#VqFBzo)Z`Gnqx5^RDG>_5YIsa^ja}XBZZW4yP4<@S|AF9nGN_0&$na{=St0W zTAwwSk?8_z%dd>9t~EZlt`i<)n?7cJ+6_C5IuS`xZNl`h*o{HeRkoNTc|Zp7-(9n^ zfOAZSm7eug{Vv|AeO~IG7-!6l@TzfmCM>|-0eAFvb~1pz6XO3*<>Q$!ZW)aCJI^E^ zO36#|W<<*?0Z8*k@JD(0OISH$YC0LX*PA{fht;;lU2I~)e7O#$Rq3aUOQ z#Er#K>#7FLo*QdHMDTAR46I2|+|)fdr{MSA-tV^D=zH>?(x!B6BMz`8^a=6U^%m)l zKa0F`k39tM{@DJD_(- z%y_7mJ5wO7yG3pt??d zzOMT{K%+fG?Ekx!5ac=RU&f3GrG;u^p#3GzD8*wJfEdW3cr->fQt#eXt0&=U?I8OP z7|Staz8jr#BSEPGyY7u~!5N_XVStdOdqkI5WGR>E{E{68ZzP?qZ4L`z9|}Q^660t0 zsdKI#WKZSrZIZQ5J-Md`lzIUTwGJb zuT5w6r&L#_2VuV$tqcFIVFSHDb^Lqb1=_!+*tECA7^FKbTPb z#Ee)xN(lUV8PI!u{abua?In7`)@q2;`wDcAZt#qfq5>o9) ze~+jFANCosL6u7A$yKMEajw55)uT;(gpR4MuwK6M0=p_YTJB+asMUP90uJnX*U}`m zFXceOsFR8TIN)AAI71p*oi4ZR_8Q>~nbBJHKH(ZUH!tZ(`x(!|6MfAef}i|$A0=C2 z>#5VWUeZ-n6E04Dx&&{sW;`?c8z~$vjg57)qPz}xNy-4a^y+jc< zM$tyLQr#d0Iw8UQr0wbK7-z_>J*o>n3}YQLg%?l%4D33myp6Pb(Eu1i-wNAbVIHgh-p6+~q zt@zhG^daVm(+cH<@|zLPw#Vu6sV`5+_-|}JKX8$fIWQnl7K`jt(>Ujvnsr&!n`uX5 zciw95XtiB|7ioU+8nIZ#7$3@@qUV`68zsn%DEvZd)d6XN4naZ1fFaG4BG?sW-L*VW z1`kOoO%B8#6yEAayR6JywB$Bms+{Zevc12Pai}w`1w!|#|0p>*8Su{BB%m$QOTb%m zr;`l^?|M{nB6JM)Vxs`dKlWIUE0B2uZDxr{9+t#!W#!1T2DjZ`G*xzF8amOqZWKn( zF}5ce+8|>8-pPpRR&#mWINxvD|CY1&kxja`iw#a?Vr{>5$jt9gXH`}fORPT#Gd-#_ zRiDMVo(EgWW^aw%ouSX>p=_AI2eEr6K%`1CsE&7Qiz1* z?a5N%pY{`tU^@Gq_HPGTa^`N@d7hBNb!=CWWRV0S^Wh|}SCnDvgEnp%KS+Y(vVir7 zZGE%|lyyrAdKsb>a?fn)`1ieuW0_KsIAYtex?un&I@06`lQOt?JaVqE?ds>79`iIX z=QQVnpKUtzys1H?>=KBFQFcdnmU=#~!NY#b9yW;fBl{s9;O%^2=4DCfMicjhPW!@ja6Y^32=uRdT z*eZXV_^WeX6P&nxkwAp*!HaTkT}Y|c>K7fRZ}3CoJ+SwWkgdZx?UNub&2Y-;_vi{8 z_)@H)0S6a%h}yrb4@JZzN`}OJx|nJc0jWg!O-POPy1s}|j_w7*f>0F0xVdUQCUEg& z&(5d_MfV?G_!vCywZNTC%WKAm*A0?OM7pYLnuy(h-apL4@lVmXBYG85mBN=M=JY9$ z$k=m0f#2n5*oP|&uk=Y#PJI3By@_D{`vF&fORPw<$S_Mko;jhM59Kt^ z%H|sv@?A`~?2&Oj{m#tX%T&sA`h}kKd9-cd4PB2m+ha+&kQN4X2c4UDKZ6rQMFbCJ z>COU<@>i91C4yc~EC^#o*^nh#`u^4>KICO}Xsp9yWkO|&OmK*3+iNx_V>)n<#;QJ? zSh=IQji{W%Ncd7waj9%c_Wddaw)K8BmRg!4`mlB>d*ng;b8R-C^X2TfzxS&~^dFm9 zYH(%jx!n^Is_V6U|30qGF_reBb2hhM=Q>o%OKN=9!l` zc0#Qj#brhrpCJ3V{J8aEy;;=dy>7wBdh>NnS*H>bwhQ z{2{d(l?WR7iHgEA1hxkyaL{)`;bGCwCydck5%$z&soIM9ltcxz@%&mI1!NxIOobuD z_Mm!TkTlr}3?6l`XHoMXiLgaU<%bSuJTVr~rcHeZ1wZZ4Vb%ktaJx7a9uR1tv3N=P z&F z|6c?z6#~Nm3GzCf3WOdSJ9WVf!%T$EF{_@eIP##O4(td~-+0VnBa<<1aCv{y|G#?o zl#5Bwc!~CK){13Px>dtwvJGyCYDn;ZbfpyyA@30hmTA@;jR>cGo%@>teYPeh?@i1( z7^FlL(`iC99}%ff;A=;D#`gQK5%sf4%LKQj+^l_&_YBj*9zFPy!#SbEuyy=BWN@6T z;-O+>ZW-@@&>}C&i~LtAv#FzOM4hy`Qx`L3O+wbMPTEfp<9nOi6xIA`b@exeexV~|SxnWvvt$mk54sIj@&!FK< zKxAo=tRa(>IyM9%j^3j0xjRrk)r?DNcnW(N?huzAMU<>lh-V@-eU2nupMEr6ZN%k4 z0a?JTi4zGCBmph9R>|9Dn^m5~zsl$#Z6L2hQ$g=)5dc^fIBSN*XCA%vAVr@tL zpPuZ`+shyW{Y@qD+!aB4;61m5F52RZAzGRQ*DYfnHq3=!UQoz?=GXe^0HYXUSoWq= z-5lKyD@#|>Lv6C0H1g~LP$S0f2+-nz_hte{!*=;ox$J9i{$~P0WZsVNmYOiDPktcD z%D-CF&Gre=Xwj4bo<9R5LH;j0Y(~B||B1QlEu3Kv=`LaaSnn+w#iFQuwGXu{>!oxP zQy#Wz74PWGSO}}stS9qQDq3+89GZ3p4zROd%bYlM1!{!?gI5qI*5d$_oFAwltPX+C z%-!zpjF&QP-!V^TGf$sr1I1qET)O#^1Gh2d6C9#jVLsNR#+<2Q+brz?gK!I=jxYc5FU<=o&=0GM^*Rv{D|EW?T zlAep|Nx?&4>TL1m-)Pm_x%rfJ26mE+m=CG;-mm3OqnQ-Paq?Eo^;;bz9JE)q3jR!7 z|FR7Ew&fHA$}wY_<73Dw3?Ptg)ZSXchQ*`ceSUrH(~1Ji7P{f`GV{iEtik+cS+dEv zfYJ32cr>}WF<<+4+jh1wf*LXCu}77u)TKD}v{6!NvtZ!H;%Dw+1v z?4gggJXpfU$4&LAwp_WyIBcVGiJ#QTiSyXeYv>CNJI7K9*(Qx26tZ6@S; z9BJHPSQlvY%<}#tIqIExW4i7^g5*A5;+1^NJaS&ZU0#Zu=c1k_rqOgEOV@T8KVF}8 zubI9$wv{Gn3x55rgd@2s`p>JZW^z{wK|-ir0Ut#=n7g(Y@f}S)Tp;}fdE)p7X${Vz zEv|fN)D&P;e#%*dwGWaToxLui5Ph0MlPr`f;-5lVK%j;a*Tvh$HU&`puFR$Ax zfMW@q&>D-by78Te|9-_9crr!j2FZNwGB$d=`A-WU9Nx0lfAlflI>X67^*Tb)loOgQ zp$|$4bMYwy($pxY91@Rpg29duC$@C|@uFBPcF6dHpY= zdBvENH6U@`U?o*1181`WDwm>Zt#wy3#k%h>^Mlb_&#v6V#`ku947LMrrQ!IwcB3OW zFhjpU;}7(5mXt7ep3ND@xmdOPe!%Q>@+Ej)ofyY7Qq#_n8NLnUr9FrUJ3Jp3bMSSi z*T&{n?PEpCrb5K@H}b&u^vxqK^o?(Rc?E(bhw}$A2%*?DPLYyG2^?~tn$$|Ja3H(H zysc>WaUqY_F%Ln~@G=7}D?;e6irQQd9*Brv3+URr%MD4KSsb$NVuK$pcwfTZw(Ef` zEvJdU;N8PrkkE5a;Pabl1Fw`WWl+7xW)z)v%$r&hTux;S`$(}AemVfWzEmd1^@;=N zX4iBi7)91p-yB#TgFb*!YLP?bI5=qPL&s50c_QUUE0Z?1-@Kyr9_r2)!Omxd{4vj> zYaBk$2A3}qvA{i}Tlism$U0?tBU|3hFb`hrwF*^^%F|})f@Nf#t=w-EP*;haD9Zgw z-&_?&wZlBdce@8Wqp$ZFv*jc0XNLEygRtU9gOh-eo1H`&n&VEqFp}!~>y6%{C$ZB; zg-=-@#0+0}3Mh7!l0XNO`;T$xi7ECmL8G^<4K0WzN%dOWE_K1AXm4r#Qz|Ca zU|NgCV?RyW>t=m7zcenYS_40BhvqZll7KHlmSiS9wy;UQF5# z3w}_WYtKR`c8G&7EjWfcwzc%P?T9DH{&7k z;+aVLf0(i1et)A7w3&5hx@KM@RgcPAy|?-0pBN@Psy`k=D510N?VRH~8Wf%HhH(zU zHUa@)o4#{Fc#OD<;}syqBL4IZ6ZSi^l`8iwSr2|%Mo?kSdAiv6hF>jMB;z|hMU^bt zGceBlo!b_St|3Jt?bgPOC<Egnn}+>@fg(?iSR)yqg;~(1pd7Dd9@;GnX-ciqDr08*lg$Z20E{xy77#{BvMM6KclMR0=c5 zLQ1Oz!~;(_MRA+``p$TK54lbu{m;UVPjvGCUKq#+U!|kmoVUnhfG2gm)RwaX7_jRt zb~%cD8CUY>MuF(YCV)uEo(0@TZh%GW`t^jm0!u|a5$@F@sB>O1BBu1U{%^Gw6IQu+ zgU67Ma0v^TH98^1VRr3(Cgm_aJOgb|SPXhTN?N9Z)9j}@f;iZTJFME*a7_~7w~)Hj zpt=H+zKX`cCV!rPJk`7V@wnx_0S5m;2t(GuuiNMQWnaY*Sraf!oA~s7QaOw*Z<4Px zsZ5`WMULZ|i7i-*_ao#N4qRRv>gPt~CnLJYEEHNnL!UB7rHZlTxw;?wNRr5+ZQ1Od zm$8bvz`~NqGydz-&Zby>CF)Z~yIO=gL?vAZ&B0~kFON6fIy4q#)8!$gwPH-*xO%E3 z+D+>AT@a}ht_9?bt(#hkSo?gi?xlxG2ucQ_f?WILl69+(UI-EBE!-aCOrf|U4&+U{ zF5skGP%VO$AAe5gOVTwadkf->S`>ifoxB}3F-33h zJsTrD#tAhl!aZv&NkB=e2#Nq6*6U21J||4njLfMa9~BrGEJx?;C&O#o(N$o0#go)x zT9G|TFJAeM&^}RSW!6S|F*DFM;%ru!ydcjb#taa|Z~fxndE#IEqH8Q`d!mRg!`JD? zT1b+?oP;zK=iBf0UMq1Ty$yihC?gUw^r0JMKMIDMrp5C)KC^vL3J+x9qt>8+xKaM-`&&d?(l*ii${W#)1>2YOe>f30zLI77cKr4mI@7?jwte*=S6M9h~nz6&bjNE&A*H3;{boQ-liK3c#?%0+fQE7GTZxcQlHwQNk^iOL5zoYGMU>1iK z#|kSyG$iCZcA4xo8N;dSXh0om%wi&y2RGa+a|OAWc|$GMYmLYtyW_edV~PE^%<}Pq z5;~y4Ndfi0fvopL0xQIAvaZNBK=j&l#$fX&LEkme__k-({INv6Xy+0|6&{IPmwW<3 z*~PG`&Rto~pCJ1xO6ah`Q{1DH{xiKZsfxg?{P6NQ`Z%AUN)e5`pf?EX`FHPhm+|Pb zr*W3Q)Ut;KH#w&rlOaPUV(_Ui7aI)vK=vDgp%&7p6wLhJA^`p< zI-F)1IK}qOFf!AlM7WFy@vqm#^ea*{xB`~ceYcpPsvZe)JelTjx&7;-fdO6HprAXX zwFpYRMLF=$pS^**_-O%F+Ix-DjZ=X$q(vt*aBJ@$=DvQ9Yt+Lr)QLvDv|J~_3KCcS zj(LcRLJ5++>#=+1?*;9F25U{<`l~M8vO1m>Rmf!F*X8O6P3+=MWB2A1N`xo>)RFHZ zS7AjqrqeRe%&@+U3Cekn2R%+C+BxSq%f7xMhM8kg0B-^h@ZJ^G7W?J%#w}-Bhf;Ww zPe6c9(G=W#=MwhzLTz`bzdTzJ1B?yho9NGvzaT#rzIB)khqx!?^28ybrs$(cMH4i6ja{Q;!k+9)Qe*e_*qwd|?bA{HFytCDGc3l$(4p&FX1Et^2sQV8uyn{u4#V z@eM~-Ts60QcpXjb(Kf^%FLp10a8)koJLylxtJzH>e#NgAGXDJ_P8#AxVBzTX3fN2# zZW;5ZO&p69vimK<5?GV(fFM)pEsgYq>li6wclS)0a)Zi0;~>4QFWU18Z3WT z1_vkQZG$sBFjU$9P^;9ZM&if{?mNmI-_HWVxt{C;AWjOL_I?kbnjFzSuOad&_*WFr zgOmV92q<)*M^a9s=zRPlfO=X@y23<&{$m5*V&XRL+yO_{u}+hwmln&mc4a_C8eWl> z#pF;s%W7N-yc*H6aro@WjR^~9*84(qME*%AW{T-E_|uD#=V^K!9|uYu)g|zH5ssF ziN|&m{fL|Ye*yst{`Gq%gct;v$AM}Oy)dKjy;lVgexb`FX&VY@!n$hHXMnCYY!$;D zyqOQ6a;0WbYF~^(W(pwDqPxpZVKt=;V18mbmXXkRfNLDUvcdtp=Abkph+fc*A`a#P zC=x`Kx#2+{Oyjqj;xoYC;s8ha0R94y&IIr@a|ojL97A9VU_Xx2@A6}#A%NzUs_%i< zR%F%80o3R#VscZb2;dIr(oP|5=<2!#u+IT38yvuE4oc#F8~VQoo#sWH%mwgf*G>Hh zWV{+0>u^MM3Vf70$vp-mB+_qX04a}j3Ig%%jRX{OqYdZH0qn(Z0H7MtZ497!rOJC? zvR^2G2P-=iJ!Jr&Qr^<39h#(@<=q58I+n~n1{j6SRSsa;-~e88Pzv|^&{G8&5600m znGK*Wh&ZZ8XuJ_j;=dRkgr*Q?9g5iv{ndLq14)6IHiP~frT{jy;gA@<$2!^tPDUaT zFLtO`Y8K6&Tabg*)m6G$UR{mJsnxZ$Wg6lDDKWWBvtmpb9+Y0uvOnjk=pa2bm|D@_ z=Lez72nX<*ga1yOtwZdGoCQRjcI5+D;{uFLjdD{8UhIETpxcs1QXX1 zVhfl8IDvii3rBE_0w{H;S85iQ&$<|oePy<`@>jI0OBv32Nn-ijbTT&?uT@mVf_zB=rC0HnSSZ?_gY1`*!Bl>vk^y@1>Fk>CftCt`y9kpPpX zX2d683Sc{85T=(V{MbtY9QJy>eb}L1shP~&exU%u&QtmNjov%W6hPQpk@I^XB-fo} zJ*t6luuNUu;{cY8O9FWBGy7#YfR+aT*@6cLz6OKF5Y}e{*oD|!15%_7ybKn2SM5bB@1-~yKq0OkgsfDm}( zhODL;Hz>#e7H8y6C*%y>_JY*#*8_m?;9xg}*EdV6yWjb>a-~*fV^>cdz=jS-R`8ac zxE3QVgKqo3HR?F$F$Yk=dI2nn;sZ!DxW;Vk>L~-*>Nuz8wO#0%)f+ zf3!=Vzo_qQuWt~u^mSt5wOtE$cGY}oFXZ(tY1Sb;+6nYHhzuSDFfV9V3pfNf2k?J#3z#+CvazeD3gAx;-F)!H=cWM4{o9YT`esnC z;NU$Oz?>I$6*o=$_&Goo4q&DD!p5$iDuDUm%|8B&u3fdYEp%B`TU)Eyg<$3^ql?CH zCV)LPZl6q~$_P!@Z~*@=c3{@T0ki^T0Pj)Aq~{HG^C|GX`OHr4wL=I{0OjmU8VBtP z8qIcm$pKX209J^<*}G%jHi0OB}00#U_ECP61^jNKTJoA$thVVE#3BG)E0N4(k{e{hQ z>q-DMo|`=wlmWatE$T!Yo=GTx|CP}rZA1NQiROzSCd(B)n~DHh@<&C!FhK-xm`CnA ztM!9tUen{S{(=g4>8O8g(G$e6{At9Zugv z0sP+#N?@BrbOE?E8Um=l&d+bZymzlRirfBJG~>d?%mY~Z9ydQ>W=#PkgtP-^ z_3ZCb-onb2UppTu3pl$y58#NMk-z;)rvMT{+JUnM#*bMMx9dJD=;7@2rT2T5Nj`2) zfqW+(hHyGBp0iqso6Q9DH$ey?Ex}nM-SNG^`o(1N-8Ar>AuAm0Fz|c2bQL(!0_(sU zMPW<R0bGGmMtXwn_!}J?!LSBx`3Sfl4;hb%SXq1aaVwmpG zBIM<`^Z){wXq1a))fq(}0wLs*btZt0r$c7oEh>vh3SfU7%zFT!-UeHX)do<{Myw^2 zRBOAN+hciVuLUmRN)f{n$J>P?Rs5W>xA5j>7|^HN3F(}t3*a@MeZ3z1vjFyRuV|VQ z;iR&V1BlvW6##&b;XQgvO#qb;Z>@YwP`t&+!$g`fFql|4QL4lF$lMNaFSb-f8_^Fu zAcS}ytCYh+T>M9Dspx>Wh6x3bkk08$0AXv5=G)OatXWh8XyehS zCV)Pw00XpPU>_|(og;d#9KZ;*Lk}0yu+YNd(|ue_UI0e0gUnhrU3dqBHAisY!@+=7Eyp0rche?h}%0frI~}ZzIV|S!{uAR z*vdw7u@+|=)Yh?;1LI4k!{Pi?=Ft%_3%smCLpWoL<0>-w~DV7={fWRiSJVg>?0D+C@ zHB16asVxEgPw%@RT3ZqT0000000000000000000000000eAPuW#Qq07+m@p0``t%t{l z>+9>=+uMtai+}(AU0z=1jQpveZik<&5e5!t3}nOBmp3;zoqnukO*?v~>gp;hD;pjjwzs#RnVAt46>V;AR#H-GYinCr zSTL)sKRi6FtE>C;=~HcOZB$g0nwr}8@83H+JI~I}yuH1TkB{~B^^=m4WMyUj{QOc= zQ#Ca;<9hd2R#wu})1gqPxw(1b&}BtMg|@b~m6cUhRh5E*f~~D>TvzOe4VE6$>gMO?UtL}0=H~A0?PX+Sz_wul0Rb==EHpIK!^5M$zrU}quei9_(9keG zKHkmEEjBjx$B!S-rCa;PQ@gtT)|uVcV{CJ5b#--eakQa9^dEA(@n=hhn=0B-QC^2i{0-@>$#Q7HvV%~Wh+8@ z6IoeV_mB7b>3TjsK41TOn`W704P~-NPn=yn*3X}c8BI6_FGqLnq;#glw8SjJZ>AQn z1><3*jYk2^8{ugS1!MUKmj}yhTfNJ@?MvzF)17}?W@K0W|CpRbA z+1XwZvlKr@_73mYckWh>ZgZ;k(@J*z+EhhdDVpjm=zTc4zum z`S-&w8oN&^#J!oG(&+W?@nb_!@gjNq#*%i-b zbS=lUE*1@}ge8U6jjicqPgx~5d&T6)7VI@otcB$KXrF|8%@kY%0MUL5(vn)%#wz7fD;3u5e)hcoDX^`l;G`r>oSHT zK>YvV8xsHdr5y|pKNwL3yoUwo%`%l96f!~{()vsNbuJ^j7Dsdew=-5m*rVE`P34`P zV=Fbnn24qn0l{>E!8_-K(g=hm61c>!niRctd$f26E2lCz`TB}HwSsy|wdsFIm(&TG z8%>yNO|msZo&1sA-82mC9ZPl66E4ZG7?0UQ!B1=P@k^z4Er;!mrqrQMyX#m3FpCL3 z$7ISetCz9J(yvU}1$K)sw;#fm<~cUaI0E==)9Npy+vfkZrIK$*2BPbE#h{jS@9G&& zkla)%b$hHyOnG*N+v}c6816~NI%6mL3aj~8+EQ&CrP63igQ$_w+wR9-?A z_|b^q_($Z1lwjstR@53?QvgQywK?4d(7FZUFcnN?8O+Q@a1q+fCPfIr%C47+HuCl% zzqiQnLpXL8qz?@l*FR(mx&yBU=Y%0?Hx>+Q5NZQ@$w{+D&`Jjk1EjM z(84R+y=Ofb(c9MBiCX0WG>h~ktKxS*?HK!;?pSjQ%0n3YlQ2iMY$`*#&3C$dKTdhx zp`fuVtK6lEp9SDT`5~P2=}`BD78->$$npVXzN%#YQsGD=-EPG zfg|Kzl-oUB|DtCR^}U0^yx{P&7@xg0w#%Xf{^8PW?FwPeUPpMFY6!AYFi@Z7*1!%R z9?P9aBP45{&3_;k<7>>4D2B=WV^G%#;B9GSeeV}~RV560Kq4)y7*(%XU>iOIdMLW? zT6HGR7^vvQ-&R?1F54Ii@c!y;!-t9wtmP<6h>#m}bs5wPI`$vc$h;Wd@j#xkI0H)$ z#7Vdp20YPA)ktz^3olVX@r$h-D+omwJQ1LZfX;I52^f8dcE$P7ren-3ou+hNR_<_(>3&`1bm}k z8GO5;Qp|M&8B8@G8$e5dSZaZBWMgYo03vo=g=2oP6^4x0q4KpId4D$@s(zOzncY=r zS(Is8)aXnv_*envcWPJgh}FF@d7OI2=phSeNNu_V<$+sHQlv4{9vz zamJQONE2Mt9;qaL68Y=zfFv1>>cHmLGG42$5!hEu@;SlVA;eF&EMe!biVIJ)SURa) zVfoh&3H+B5es`Eo)NM_o^WIs>UpunNFOiRUQkRDx67gOfUqVZk&a(ev(1H!yG;&CS zVJep(-hmR>UVzMSxD>oe8%4Q`%6VgWn}U8cWRo@ve9Yt4;E*m*KweTmkE+Pt(d9ITnMT`!~y>d=UIoa_+&(=;@~HuMv?T z5*0908)|C!jVZ>RF=5(`S1fn051V$XNi!RV^Pd1#G;jU)NN%EzYx5$>L~nzrqhAsu zzKiC)YYw5HXSAhi;h^0^3yMSu+M*A`R>MX|qw=E(TGdj!p%t5rkD$6{Li^O(Li_~E zeD8fJl9HK8f>+2JFSvh2e=XAZSwn5MAiz`Gt2$L;#jySMd^Abygjrqmfuy$E3vzbe z54lxpIg~o<3|ujz%3Pk)MQ!;mBg3o$@jjP&xt~L?y(bZS3|T|zdOVdZP~{uZxH0RI z^0BoG+bWin-ti0{NOxJ_*zwIN%L;m2y!eOMYIy5|c=r%Xc3s}kd+SdLwQesgI}TnF@KH6Ykq%;+JFv+ct`ZfKU6s1b7aBXXc66E~0EL*)k>U4aB3 z!}IzEDbO^>DtFdXyWYWl_t}OibJg$VX|(O;ZHE8L`QcMT=vjOF6Xg1v$sh0YuI@XpI}xac^-Ir@E(q zS=bY@+)0OHQ{`|UuV(JaW%=sMVXNL>8j=W5Dpa@b7SFY{Be9?Y z9e*T>F)P3@JK7o{IZbE7r<50ZH=%a-;sk8Nzb5e3>6s|B`?VarE}j#d7ycKcU3 zU(p6cxw-|vb7fj(4oX(F#$pVc_79G)l~q}KGIi&9lU52 zc3i+zi_jNd1x|8@*bq_wdE0Oge`8kcP}sI??y`wpTCjXakz!`lxeO$RkK)e&-wW`& zi~Xyb1b&2y*P#8v!vrSlaDZlq>b+A5ghoi+Hfg9|dAl;0p!uxP2?2y6KG;fmoNudq z1mztzgd?G-WpfG`S{-UY=6Dj>FP%dzQtUb#i^A&#M{;W$FNN&tq4rUK|OW=1v>G-vH}Leq906Wm;VVPd0{ zG7w>$h}?2Ik?cw>{!tavncw6c#KC41uhg8ub;53Pd$g7PwQ-yd2QJ%3Rmyhm4qt$t z?jpW=0m|Y6JQ~Pu$@&nC&G)iEMR@ZfU{c+b<`YD~F5p2I8IiWCW+^UXXEl(F;nIGqk}DBLIkBoQCmn;EITe zglO={35-p_9r8B3Go2fh>}s5vxVF!tp&UdUA5K5L-s>SPc8p=;Q72`7o0w-wzk=*G zfNv^a2Z!rp_S?w32!ON6h>mRUT&$QGF}VzoGI*w;t2bF0&iU>&&w|n7aM`763P{)A z`Kgf)ktKWP>z8VNUy9NyfI4FqMtjTV2u$}luS3TM{*CNr;GSNbv<99VSw};SNdX)h zVrY)$&>1571t0IRAqkCXPL1sLXD!tHE}jFB3DoiqC1oM+=IT~nWWu^c{>CxP(ii;N z^2Z(DjntTe^|eVwBE*`*jI|-1DU{^s1`3LGEHHen%RW?D`<)59ZIxR;l-aFsrs5YE z^HtSW@fyW?%L5}gz3&Ss0}|Sz_Nc5gD@>L4rl~_!lyS5yyE79&`P4D8xS1ctmhCvi_wfXbweo0XB& zL#oInri-G*elr{L4>nx)-=s@kXgW(sx(N;sxV+V*Gw2e86-#0zl7Y~5CVuf+4bx9` zV31rk_z%78(&0(5TLp`xURLjzwaWVyrIVQK68)rmwK?ioVCbj{E0)E)iZ_(?@(1ah z4cbb$gCAS#gHf!D9E#&@UPifk?OskI&6287%J_6Ed@3O*ULN5%iz$)QCDb6~p^&I* zSGttce7yd>MUu0iEX-*z*V zvLO%zgD~FF;a#Onillv4?&=2PZjzu}=ToDF_4_aIw7x{*n~LfEkBV$!P<9cM93BOG zN%7H~!wpN-Q4Gk&42hzYbm6N;2GNdbJl8uDjK$|4!61(Erp z2-cixDy~Sj#Wt@rsgHV4ZF{y@rO{w{=1pcT9-gw3P5h!Joj^3wga03;>p6$3UjPq_ z-`WjNx5lj$z%N3p_8Rke#^>gE^nx+xR)` z0>b>`pp>Foyjqg{`mcYUseX%i{e9YU-^CK!ivkQg)ppj!{rr=pJ|Qy zL52L~4{I1)E>5$#l$&o+1rCmm1yN}22U zbV07XHG{9XFP%6Iu2SEpx8*J&y{lkv`Fgt9fjAxwc&YT_FIPq|qj=$s!U}g- zxT`*rTnytp$K*U1oyBOF_GhUwa$}!W#1Y}HBvsj9tkJDcLu^VDX3d@V{sNJj>p}*C=40rwO z&ldy=)htUsJ6ckZ-cof$gL3>9p3xun#{*RPuf>#4w{x{@O@`=7AfQW4%!@3e=Y7n1 zCV$RGBhaHq#_{>4eLT8jLa#+7&CHv+!AXtof0OxSXv){ugwGr2oBiT{fzNMmrZQiq z$FPQ@Rn710BLI)M+r(<7P7%w=7g?X7!xFh?G>yKX1R?)NLH`|!4j;VPV8t4)e!&hW zJ3D0G=i%anW8yU%wl|3(Zt6&CKmztNf|p{XR--$d_xRM1$lsh@X+=pwen>=lK7PgY zpf5KW_e@mfKF>+COvF|ILW$8SfYS5uK&YaW%8(EbK0MH1XUj0%X;+PH^V52TnT#T> zM4#{56}ZYC#;xAXvu^WlH+mbI+?6>xMF+Zqsh1ws=s|Kb{lB!DXuS zQ2|9W%=h!AF;YGiive=J06$wyIl!+EqnME?1LN~2Qi#;Rm%EPAQ=pm^iOFH&LZUjv=v26LL_cK>PlSI6f-mJ0}hA5 z*~Fv-@}%p$q9p32P}8~=*jV8OBWxD{`I6ABI*fujm5cT0R)hH8xK4lIu z4&aMHrlS-rvXTrWNow-}9t4uo%=>0S@rqKYPcwxyE7=m08mi4BkVO!vkEi%v5$py` zVVBS;CJ+NB>p==lmcN0}c^y+1XTIq$8O%2eih2WCq}H%-s%Wyyl6^yk3?i;c(^1s& ztG)EV*@+6cdGtAjN@y58Jt>S@_+pVEl1L11;n-xr0&CNM)+yGE(C?Kac)QMKW(Dk* z;g>Cy3=D*(dQP%Mqa3PIdd2fA+@Ahkv4$DMw3c2-eJ>z1OqMVTP^bgArg)*DzBQ*G`^}i z6+j0t6aVCjn}*_IHA5OrY08D4jrrQ``E})wEmog(mh-$b#93njq?)IoBMdtahO-~a zau;a%C~8tLI?X9Bgf69sVmshUF!y(m+`Kg#@I5{Y?iv1lnr*S-j~j^uoM8C{#6RMF zsiSM_-b$DKaDMahn($!9XsWE0!r~ zgx8>HH3Z39?qPMJ{C^eE#}e*LnD2VVuQ2_~JlHy{$xKKUGafV)>p%k_nR+R}N_19zt2W_v8CxiD--4ElqY_Kh+(=HV<1CFeiCYWkH9nnAxf%pxWNQ<`;9BTwp?x-wyM98~ zLY%je)mkQy;EbvzP_9eXJViJc!=J{SJVi*AvtWcu4Q%uapY0!zyCN8*DzZK{@KJ{E zKd$+afHd(i=~k#pGjl98_>4>C(D=04r6}JM{_0m?)LyV4rYF7K@2pma$Dy2UiTYm- z)LuB**{l(~aL=4*JcYG>z8?=*k&$?prp_%cgY&;hfBNM0x?UN|fCJ|SP78K;Zz0%9 z_JE&9CMTcQ?^P|bnwUqJQEC1+-{)JK8nf^M{Vh(TjF*sdxSm-uSrXi0@U|N}2l$g% zg)H|>o%#P5wiTwNMgJJ{KvrGhu{wP*q%8d4vNhlr+vGLrrwR2vJNG^9|5m*z($Sal z6F@|aYB)3vI!o)leaT_4j@ByI24o6e7g2kcvkH135J;NRP|pw^;<~H~0{U($kWTmj zxd$yht^H-qw!a$dJ6@6uj&xs9D<5O?g#C8@v_zrG|BYAHF)F44S|B4qIlx>a)~pb( z_-{Mktc`2YrK3Bv2O2-Kn?x3GF|)s!FhXXeZc^b}a81QM`?HUl{RFJc1z?=gLd3&v zIqIvUlax;BD$6Yo)n@i~vxGrG7ziuZ0jj{^-(4RhN`~JfItB8^U!6?wQ%4pbZE{pHZjfC(fw)&Wf#e+2_~t$|~KOxRGLmE(3`a2UQE zlP2-;tqsu}qzotY4FGYb1iOI zdzv)^Ja?gTsa?4@dK7-Xx>Tjk{;ED<@${DzX*)qCf@I6ih&kD2u7<~&z@GSsn0maJ&$c^an5C_nGUP4}j z5oxPCyd7azdo%vx3Sv>8I}cG{Z`R5-5kAnE1y35u7-0sUcl*}Bj+Siy**y{pg+4WC z0=~rXyh9UjHN$m;2znNN-W7TwOp;daM=r5SE*QW~w#1FunY8#+d{>O|d=&6}2pmw? z?0G|x!_aNKr!q6<@hqd}s-U=XqQRo}j}yqJTeDwWnu8t>;nO9vNBEGo(`0S(cVBno z*WleQa6pB)@ylj&Ty)X?Bl;zC;Uq~(7=b*Zg!{YnJl8}<8n6^GKhW+kA4g)LojQO( zCN}A6^ZaTY9Fv>V`wa;u8*8X7vU^W_;c^Jhoiz?cw?-tEeYO8iC^*)n6hH-Gvl3t2 z6#keZ3$Ao|&ib2g`h_Ez>+dA}bE-FDUXw-*c=v0jTTT`-HS5oiczYt)O_P!8UU?vK(2c&|3WT)&f+5~^^Lq79$vx%3FgC;(04FGXpJNr4Jf>BSIJkNPN!~jK z3{)gKyA0AT!mSTfW(@R$M1kK}V4Dq@#;n-Yz&YEf(w!w}Bn!jCV;`@R)thp^cQ5hw z0fy_G-@IzlWJzRQeL>@AT_`-8{VHGR{iS0af?C2px@I{9MM733s?Vv63U3V~F$vR? z3Zwo$xWcMqJ!njC8fv@oPx0fBPAeT0n*qbr-tY3AEwvBa>X z^y}r?8xJhbrj4K@ldTqbzj&SINy-dgjt86j6d8mGiEFfg1s0Sw3y|i9NQ2La&okZJ z-N^ZJ@_)5;eY6MUkU-lPjOYx8*)AvlGk0lN&Le|Gj27+ZzXPaan8qP5*mjizT>^%# zKQJ1cy}Bepam!*$5n3snrjIK62MmYGsD*nvCjGPh&wUYrly5SGQ~0n-UAD6Z#HuOlbNki+q|H|M+UKQ z(%q5g*0YnbU&;Sh4wR2WK{{JtBm5r=CY2`VO(RAFy&1n(;R>`QP%ic_IhYRm?yoNC zUBw_~I-g~h(g-igfr2h#kP3cS#H{zieghI5dJp(}EEXne9_GG@)U-B@S1RW z#ew_5ByLr{!yB9b z={Y-zQ@LM;5v8-v*aF0M9IRGHW#dD1Y9}3XSIHpwV#sG>4sVIdEjSNe$*j8rt}_Ag zc?r&#P}D4N5m7mlRW9(3PL=givvf`)a<B0#umzCj(nK7&wtUt!4o zt*w5}y2!WP%SA=P-t)_$@bA2W^mP$n24%ZNCHwuZ0`&Dnc%KFi!q+;rQj`knld>RH zgz(6Jn;w@EwDO%lm1)v(2)5T{(H1RP_EN#OGH4d35RWa>h%MYEplDY?8`H z&D%q{ObjM04%8L*qn3su|0SZc-`-rL8Z zCNUb2@fmiciYTv5d0!y{E^x;9FndBb4k6v)faP1N0eSCuO!2r&2{0wu(US(5G14>CJPz*p$)^l{M0A_<2htzN5-&v*s&X}*i)^KI}wINIw zP%-?cSgH_750!4hKfW&5jqk!_ivdo*symugfaG0duVaPJcH6~;!7E73@)2p2+C4`7 zH_foL4nU(8u&{#@nuspJ-1(?>yH$*^bt-R_(kWSp)QJ7+AqUqLC=Z*iVYmVn#TKBR z#h?i&LW6|R{_B!S5_#!Xv=lPK$%I@i3r0}IHPnE`>G?ZlsZ>5Y)PkC2mciiKN3{eD<#3V~ei?R4?TG?>Mr}F9A~ERt?$Q}(MG5ExS(Q%_6hz{R$lRN-;=dRF+MWd(X?QVO)F;vlnx{duHB6d8fQYk~ zqG4@Y&_G{zoK3aSqQ``zH=s^TXG2ONAuwGCk_6G4zav-8D2>5-C?=3!CXf59|3;m0 z)usw%sXgU^vuuY52zA4R@Z#;t)3;Ei!|Z>xvjjgcn4vToJc*I)yrCj;Epp~jBV2x+ zd8AtK1*E{m2!bc4YIo2jTHFg|IVep!w$taz9Qh;$zWlY zm;&g%>l^SC0x5rCKTWhekf^lFjqkA1;Kg{26HGtOb~tSav2uk8mmW8wpQ#arh z49>@ox(hR7`|B~y4FGHr5fpL`P#)47dPATBKvWu+*Rd zWe8@e`f{vpE8=_{Vm6YRJ0U!<*0$}F^8hcG($xf6Ha0#WpV}T$6GkTy+=kSM@lrM4 zO$Hy3zq5y6nSdWRI*>?OLg5^!mCP7cA0z9=<91@}=o}fv2;Tr_2fR-}(_?JN_a>yW zfkg;+?Q>Jm<_^mO7nw*!NH>Cnn|J5C#bc0C`429H^9sP4`x-LI3ypj}gR$=TkwLN# z+-*DN(PQ}v7asi!urEC@jDas&F!#VEFx&t8t)x=#&xygf+K-CpG-Otn65ll@eoi25 zeE0>rnn%9da5ov8k^`9dI0sW@MjWTd1b2}oWv2-x;&c|v#xV{!s!!E?p0;hKZ``{3wsG=?aCbB_n2I0%o3`+{fQRH#ZV#5kVLK5hAPb!HR zf*TEVj=ZkBzS}?z|APoZj_;SR;H+DM#-wEtMqoQfK)C?6Jfs%0ayIzlP_7j{WFI|b zmqgHTK>o>5TzZ^_t2sr+H$>p)L{4BahXg*8;TQS)uTg;=&)4pNyBl)dmu(R#Q%4a* zZW*+Rh1+Vw;GHVLcNsz`@1SBJwv$h!?nnC4a**v31|j^cLQ>NdG1HuNeQT>x%&QM? zC5T**4W`h1c*wD0q zb3!pae5f&CckiZq&?Ogf5Gi3alK8{|=o5TXy_H}RL7xR)=-ieGW2c8UpRI(K-R$)n z$QltB(ta5@GMJ`a%WI#jj^{%pN*Ff`)jj!~*`RVv%cYbhkwry9C=9P_Qm5`Z4#d2+ zO&E>uaglfaQIlvA$t(iz!08B`rO>n#)n)ag%)nIKQ8ov zERm?_HXHb<&ej=H@PkSh3r!4w;jTJ+x^ z_GpRuJuOg(4xmeL<3l3@d{(W&!2?agR1Y!&2()D~*fEHGN4(Jf=^77*DIIyy8@1~L z!IxqORl8=h-`lOkd9P_7Zcx{?aGteSyX7J!$I7=}_aHO2A{T66=tf-{(=VazAK6ak-Y zJPTeIJ&(hyO^5urh-P=lqdvV+zLp}<+aNQ#xOpS#P8kqtBp$5+PFG&GywspfPEM{O z=6Gl68D1-xA)S)Kbb)nId2I0#RgH`4@sx3Q>bJY6<1ZY?1D5+=y1HWGQt<mB<*WE7k-jU1pU7$U*{K5WzgtibFKUQt`I6aSPs7BU+Zb)?o%sTCDzvH~Jx!WVv=IxqPW|28XQSMegJ z*xuaQYFbyx9ljs5h4XwSN9dE9)X9qg>*Uqi4VIaK<<+Z3IO1@KK}a}hpc zA={M&+uUQf)Z*vhS~ph~qP50PJ{8mKRw0G*gZVL3_3dN@*SMqBX^f?*lx3to@%iZp zug?--RxK`Om^9;@?~i5dj{lmueZ0>Y@GlWxdU=QOVn%D7S8t$#fScpE5o8;r`NNJu zz$`heFG!nT60K7bvZK~yJXw*$sjBucY9Y|)xM6eB$%WypKFTz5M1d<*7^3eOOMxiS zxLfbijPew(ock0ziaI%O=T@$PS@e`4d^YLeS=PRAG)bYif7(Uy;ff%{%v-5ULK3Y+ z{L|4X`WWbEpL|TI_%;h=j=ol)`{VZm)$2x?FQl(#n3`!|nHEX-1}T=s&%R=7Mp>fB zwvZ)lZPPUH?jq&~cZ#|@M*yaUrl|&O?@Gh6?!a?<6mM_kH-@XVEnaku9iLwhH;!GF zyxSJL8FqHDeI1_>f(iqOL0$QO_61RZa>xahzu<56|9W%II6%Q&53nUU&YRk&-dJD7 zL!nyvA!l0)^2EkgQ@Vsv;fV&BksN;ry|@CdK%6P$E)x=LiPz?3AR#dRFHE7j`-Hx^ z@{skDQlMfDvlBl??)!{~xiu_EXJEk7$5<<@up71Lf?P*VGZNW{z4tes=OyxxC;Kn2 z3xA5^umLfYL9RtvoSe&lL|^N!)y*=6Fx28ga=8~;Oi5*z8kIz*RCe2u=bp8R;HI~< zEE6uZtE*G|CI}>CA(K0AHV*`I+WUv^zrvjG9CLZ)2AU7=vD>_J=AeV2$Ey!#4b1aLPA zMv$3v^9>S3h=j|}%z7ONy4WT8&2!X_Z&Tpe%agz!XYx{CNR1K4!}sil6VT&_P^s(y z0f$mRxBVAHLOY(t*}PE!pd5$->1q2W$;^TCp>weTA`qTOIef1VYCT8>ER8BcmQ*=N z(nlMPkNpG6MWDG$ex`>*PV>=!eiN1loR4rW3xyMLEIn`Hh4g=f_;v5yB6qs{B!`-2 z8KwKA*4l3L%PhTx{hd&*P3Pi)b8$t5tuH!(Igy}OEPl34fHyvF!@Vp9jjExxLj7}{ zJy%i6);=T6pHRG0sW2d&E0x=z_h(y9`mxTf-)!$^|$cfM{emCPA^?pzGb1X|-oXn$zu%uZ%k;tPe zc9|M&u{A9*tX{MU#Uw2EN5flkeqrDPcHjA46d5e z$?%>g91F$BMB7!O0;}}kWAU@B#iJ17iD#tc>`adIj4ZQ@iA>gf&`z%;hCCrsbgw{n};PKM^SUC&_-r#V;78{**fy zv7Bin7jLJzYM3+Sxs|Jx8-HwGZJcV7dssbE5Qr8G4{fx7>Ay)y`PD%?#z8CVLx_J- zG8qZgl7cp4eVl*F1c~4|QJXrH=~<%EB3hHV{Lbk}1k0sQBmDgZ2&HOYu`RsxxkX72 zvXG{Crnj-C9NOpl=t=1Ascjvrqm8ZiVusq%W0{n90;$^4vfRcj`emb=3S4>%ZF$gr zTC%^sE1QY#=}wrodBOVTDgT|)t&~2Or9!^61i9>?GDWbQyNo-##NoYImW-}((m}^> z7GBfzkZRc_x{JSaasAJkb&IYTF0$z#Fi;Bl6$dKJlMND0^0a5bvwnK=QlBx3o+JHj zCMipY@njZvQh{@?GXyLC+78rEnzK#RzK#yY8H%B&@z$S~sRU1Bxn22&==y$ z`fhW}ZV$vGSr!o!>DoDNMWV#wY6TZVguB?W=P7Xmui1lM)OkWN#JDSo@RB^D#;uP{ zFKBvmW(txWMjxT_7O`UyBn*t5ur)>P1^Pw?sivu~FQ0*HD63&}Hkcj)5PFGxBw3X0 z5|Z!|9vS!xy55u-A%QwOu%#5$W&Mlim2T|63Z+fkN6XVA{oi3ZT#v%P&CV#?6wG;) zswz?aA+-GFG>s0-=5H5+We^ZQic26mIy|x&5!BV3zhN@C!>+x2OX@z;qrm9iCc>K; z^T2m-(B0|{FXb&(OmM;a71h@@?k!XuNm_}z!B`k;Z0orzl3p*vVD96B@w}E z5VC0JK($93Z;xBlnV^Zx(A7R*IV`Szu|)@8))e7yOJ?zwQ}}sfLdDETb#NP)!w<>) zjop?c0bx7(8BAHJ@!oa}Eem;8cqsi#K_TxV9H(v8XYO+lz-=`Nrgc%h%%B=cWWCwYDyM<&2o}=jrVH$!T9GDnf5S>qZm+cR7tl3==zJJ!jyL`AAo;44Nn$`H z=iQ>VaLGG^jK)lBn-2IVjAi!DX}2V5f8cE^8~0Cyk)5od_r3y+#Z|LSmnN_7S7}QFInOkmBV*vDTQ%@hCKF7ia0lDdY#o6xfnZb$V$hg zjTGOKMl%9;QQw*#=l-V1qf^WU8tUrV*Djht5UeIlcsY^Al1B9Y;z_rHbSl|gnV_P` zwfzfxZUFU!QTYXP*542hV$vAhW zvGsDd`x;LZ;f6<1#^wOf{&^vp^LNs=G79N)?o4#-q)k@OJ*o|KaO3wjZQuf{smw6Q zg0vtAGFAbiZAi2ias=Y?Lz-p3KET<_VSQKMKIgs*O2~YO0`vrYL?Di2uxXMvJx9}< zsn%1Aa*+Y@wrH}749VU_o{y_J{lLslQ&(C2JxPX{L_>MZ{Bst^9Iz8tn91|f?KV7O zm>*a79>ibG#!rY?ySt!c7hkuNM>JG+_7b>9x{aCRm=7~upcl^OGtjIAm?xcVd8<1n z=~oZ1#8bak$B-4NB+$qVs-pm|XLL+Xb^vo6cens%d55HOG!=6@c@{0pVPxF|&Lh$! zIQsO!;j*9(UIx6BHjqwZ*@n5m43fh_GYj?bb(SI6`p=8jPq*r--2aMWmX8($A#o=G zL1l>yqO6j*BFfBByZnKypNKA7d)WvPzOdCy^XtcIS^jvQ;vE`{Wu?rA`QyLYk+!Q1 zF+-xhFBa%Kaf+bF6)%;jPEv)ECH1m3h45-fN;DuT)v!^%X#YtdGFZPBf0xT9eVZWr zFsksM)U>{6j_*fzQo%n-<~x{z6e{PWhVZi_ZLeN^*9!eP-Z#cl#8145{*a&_Kzt)QZUjNL5paQ3xRh3YI-O6r1u zBeYy>40!10%PIrV;S2O4TYZ0^;mx{Z5^$iJt!_z(n7M9N?{mI-k+@85tAbpu?1NN8 zA^&2)_i%k_0I5Y-@9~)uJ~B=iZueRBBZ$Q?X)fQvPgx;jtm+Y|z!$4MuM!1A; z@r~!6-YfT)@XAUvb8gxfb5a_zNVfk#B}T6xYwViT7R&OgX|(Oa&k3QSpX`6$q|-?+ zis#{>An23>ke&Y-0-#mR`_X^y~j5-Y|<4KjAQ_Y`(Nb&%@;ORf#PWY=K(F>Q0al=EInopdT{o|6fP*2vg^|z8`AiCT)q?bV_*gVI&sBN|L~#gZQQd*%mli?EieD zPZ~q250+K!_yP*G4CU==Rm+W9bdl2eBkM{Z*Z5PdQlmFxaJsmac?TDq30=R|A28fjSX>!X~gSAT5I@K$6ICS``qPSu^G$)**(C|b1swqMVXb`SbiQ-~Pdw&ObXWBD; zK*>Fwj3{Wb`7ylH{3eH4-*5j*!?Vw4Q%!o^1sqWU=oOo`f3%%`k^x#;!GS~%?eJP6 z#21Tu{wc)Oap|)4*{$^B6KdSs!)Zy=7owWdoMH!A)tlMCm7Bv&$}=syPvSVDCfYWq z;q^Eav~CpWxoo_ih?zZq)n+`X#LSnHr+G2ma1xdxJ!#TyY$`z7Pe1ys?iB_PbpIc= zzA7lL=Lz@hF7EE`?iy@^YjAf6?(VQifZ*=#EHUAE;x#jx8vqRoq5%76P>|q0SZO36MmS31Bp0NifL%osT?! zk&z=G%W6bxnCk+nv6}%15Ar`dL##wCN|c#|Ss1gdaqKs3!g8`9lFcQvg1q<7nwXtG ztB?fBoe76K+h$=-;}E-<}ai!H$y7x zmCD#bwhk$f4#w6{a0%O-6k*blp=)7ks=n&smokxZA z+(#q^FA-uL4&LlH&(*FGWLAVk#)t{ zNDh4sMj9fN)5=Oz_ly)Tr#gM0a~`WQ6ShS@DJN@FMh8Zp3v+DE>3)r3tv#U=-?P!6 z^c{AQN%)?jW~e0*-fLjz;?lEM-3&#-l#*$Q^8_0>&Rfzr4!1K=GOBr;E(?GTLp?eU|JfTkT!Pe)B8MgyXBX^#7J`z zPO5^bEd}OMz9bk<_OZk+VD5=W*gwgo_$}q;J+Eeh@CS!e{)g>ND`TM9ll{$^KlZ3W z+@2qtiDubYG`MLMB1XbQ-X6!$-DBOUcA`rSyACBJ@Woy+Yf`4kr97pjG5`C7wqekQ zybFHIAs7q91bZ`7$jD;5rBf^TRMR!<9z#CBWJ%@w5j%?dhMIeL6*nyF=aO>N@W&#L z8kMiZr34oJu|^GyUNCJe-VL=xV}bHzbs5HryixBcPa~gF(XsJsx0yBDNJF1Echok* z!-OOeUZ7O@1jROllzqs)YV9m$*RNt3)1PtYQAm6rA-=12{aaG}%RC`V4Zo4RP6`#| zE4b(!N|Dr>F-dHJ#r&`GJo7;2+^$XrF8$RI*an}55pQtAKbOi%A!Jms;&Z}HEuM!( z0!x;AmxED;4ID*!NEIpVcPAOIhqKGkPF2eIP0;+laKgQY)xKtvHvkiL??@H}rq+6q zicb2$FJK>ZVcmuKH#Ac7+R*ubg>(jiA)+ywUJ}z(BlChE^(9i?|C;oz<(%9IMNF*Qo zIT1WbU~Xw^9|Ko;JfxMahZ<|cjAijs@NfsI!Os;>T2e?u2)C~q3;jMu$ZqzrHMCdIwZzerd z3@jY3G-8_-(A|wOo0>d8b-!gIW3w3Zw!cRyG10v@hbc_Z3S&|Rt;p?tQ6_(NhJK1u zmyvwf^RfN(y@3YkpUcvw932c+8hie}@(GDIcf?Q+c9EX~D`7en} zive^MN;@orL}SS$F>gusy0eg?ifL{kK`?!P^ujm;??YF8|DRnZKcauP7C`Z#6%l;y zvR|RD2h7%pzZw{E^;wb`eq)ckZrKac+t3>K!fu6gPdBMCRc5pwi6jGC(5rUFq%y%$7 zwVJL*jZNQe2e5llAJhP!H6OQWr}f*4y+Jx}o=T4cfCsOTEjy5R-5u3m3DYNyYAG|{ z4hL6JU-)wm@;LfOXa2r1BB~5impo%#UpPJF=6Fk!{Sn6c#kVk2`?)xvswZ4W<(~r) ze6gcr+?wN{XuY>#Dm%w@6_Ra-Cig+hAt3pbhDqqOU$4W*&8?HXH0&Q!*W3nlUR_#Y0k)l& z4+Mg#VF=#tbS$t$*s~DOG~5}3IxGc_Myclm%I*V(mk$Bgx~4nDF{*>mkWlT@{+#(n zKN9aUO(M8gNJsqVwaW2wrUKbvedsm`fKCMhRaBC;&`!ew_BwVF`0MzACx;yebol5D zJ8+Q?JCizs{T%Y)J^F-P(uP)YI|>;!OpNvm`Z9GBQHBH;;3*|M4TY5afta0;Qx&}v z(l1Cy!-UDsO-Ui6GRz|_l;XS>Vh5}9>BHvfqqQGvUm-YU=W()npWOYfu~DYO;xj3!qQV?7z8pSTzNVw5Cor+Q zXT$y@RmLYqWQe$NO!n+q@cgC>wrP4hvi2_bA1UCHpkq>oO+(t($?%`*^^9pmrv?pf?#J?v9AR{zD!Nwf zq;~!@>UXG|VZZWbd!0)Z_5Lg~&5E=>=x$>{%MQ*!m$E&I-2&m^f|GKZd7oJh`Ymp~ za)?G$QP9;$st4k?c$9c@`nUc8uo$bwrL@D!#ib9G9uM?v^|z6TC4Y@z9#)tXLpd7f=f$jNmo~_D{Ao&TjRU?`4&ERhw)NZ7S{x_vVt>20oX4!4%Y?PUFrP)HH#P~jEy}Qg18Tr zo72^mV&0IZ9qAV@VAi^Ll1@GC#%rRG6-rFK8k@KyEKGE10+O_{* z=`V>eWw2B73iYYM@5afrsohqunJZ+)oqBGAi0i+)71Q9HZvC-tqAnEZqX)R}VBhc- z{2tHPiu&2JbuU}UzsIo zFh~l4C(d%#N-oA{f1^TDvEIFb75KxFO?3t2h0auqFWX_zw1#23?IC)Hi+HI5x+wmO z4pPJ=TeF=B+F~i~nUIC0o%GAJCjG~%PS^irlifDV5qey~O>*%R_DmtA zHLE7neT5`w^S{pBcwm>p@&dAa_NKthG|@M~Rdf>x);d1+X;%dUgto{_Y>VUjP&T7F zV&i+Gk;?Sr!<}n6qW8X{iNXCy8+-VP?Xyi7e-3rt&t;6fvIgFh!(&d_WPTx@Qs&uF z9g}Ha^SFEiY-iGU3)r=3*4eh@YpPYIvI1Li-cRMl?TlOYxn-EBeH8JiSdJ&lWFG=^ zBBgMNC)?*Bh2RHcY-Fl>1~X;TiPV7*3NuZ9ScGZq1qPTXxEF~aKwrepEO$A-&Z*`{ha zLp{LO#_(7ceUw2=$CrJ7eAHQ+4>kx$M!#N%_<>YAk8caoe$5b^rp;ck?O$S+M0M&1 z1@WAF0qFL*tebkwiKSTz<}J76E; zoSIc;kMMOu$+-JQtE#WuWYejiDaj!GUYkn5u9VpiVvxh0snvw+uN>?}Sqz?;mx6=_ z<*PESe-6o44SgWdbo&~Lb#zc9t3qSA$8~U$ZSkNY6hH|6vEjhjGw*1?`9r-G= zVg^_2`lVIOl4R_(t3q0cqB#Xzc=dBKlhm60?8pYBW);c3AmBy-wzVrJV8`f)G)rzD z)GdfSd2~d1s`h&}5Xs4l8x|PyOVL3dgC@iV@OfI=dwhFh7MK@X1|(gV4A5)-;&LpB zWYmo6w5SlDUcjQk%V1+8vvv%jNr7?Ck{~jkk$&5dw|4wJvL&sMWY&~n8dZ%LA zeWmR`-e+C?72|ISZd~`X?8&Tyn9s#XUmtx^Lc(ceY7$mxO;z}@kvQx=NTFi&3@bQgr-w%UboOtb_%=DhU$xed>zl&AgS_F|=VU@|meL8Tv@iwO5V4n3!juNU5*xtjy;sIQ_fyGt;yTsKtdRO)vAhhe$NcFg;7z+p`WM*6Mvttfu z4VIG0#+RbrWG&7+SFI+1)dhfBBJIK=`bS=fEEyRYLqf>8&>^KVsC#9qGk-t#Wo@9A0LS_^KUUty-l}S!?+sZhbyKXJ8%*pg?!T-jZLwmxf{8UhFlKj?u?l+Pi3_3}aS z{n=N(?}9vnuJ_kpXT(KEuSP@l*f_W~Sf!$;6h7l>KC0l%^@4^66Hm$fA@z358mIE*n2e@me(EiQ%>R!u?8s1h;U>H{ij3{k=;DY39<8wA>RE|QT zYfo|r5{WfB4+Cpd8qJ0`(vZ1)SxGVgRwV6pb_GCDSm)g4+1c1)+!6B(crs@Aa9KJJ zWlx)SatnH^l`#_zXfa-wPb^6|DbP6zv_uzut|j|zKNQySFRzOCF%-ukwp^gV(T}YF zvLTd_OD)Js&{Q%at^w5P$fY>}pS(Z<7t72rE09T=R4WP8(d_En^0L6l(|>~8EfHJy4E0`lnPbgvG2DkzLi_Y ziy>@ja6NW4TLI~+kg~iuy5rj2UM^5YZlMn-c(;9uaD>jE1Z6-JATe!D|KYt7xq!v> ziWCmltWuD14$lRccEm=0(kbekAu@O7-iAW@<22x z0ShYCl&qmmD}~BD666la@Z*^aVCCTdSh~9Miv6=xi=ttwxY3MRj9?6g_EZ!s%*}LV z4fRmb2U^l&@=3{RR4ix1pGbZqz*%+)v|h&Xq9_P>v?oH$&VLCq+CXB5eNXbz_XHi4 zyMg{7Z79i(P27KsebgwKuy;)dPZL0ZU~GkGVug4r|6by(H&ql^uywYf@BwW^@xv<5Nb(6z zzB@zUF3A}#Ysz*HZNLIfd3@j|=(p%FWJ4n;mN`p7*tfrO@hmk_T<-X|327l_mdsx< z+HZPljfYt01q(ej2nf3NTE+mbw-S&FKSH@a0V(tFaX_9fRi2E=eiSj~sbNSY>2)}p zk+HE7J4UA#XpjXnhGQLsMRNt?$rJ;b6_x*EpcCyA1Vyn7=po8{F=K~?XQ3^-@X&5M z()SCyM&to0q!jGc>kp3jvXyLcXh0XCk?X3_44(oZOn@{QfH?{n@q>aD?@ouD8&zIM z#CDOgjHU1+L#e%aRW)~&_2ObtW3At$QUJo=>3x7844y_Ov&QxTq>XM3C_oZ7<4fne|#;Cp&djsQ^U@E`X)SqMbqLz*pPz>WxIkqfkj$^R8WvhQ$Z_`Pozea-M>H> z9EeC7M0zhEUQPob=Wu6yS5QWyCuHM?Cax(?{ z5BizS^O*sI8aFkGQz3~%5R~y(Zm`W4=zgk%r~2tQpnN>wMQYJs9|H93jRR1R=EPou zYP1M7!%!{4C2)>M|1M{{iid5U75FV6f}8|<%<}HlH(x?UQa9WHavVYK2HZ91+AEoi zg_8{knIKiNbUQnYf;=vqibRHDYtfXL3?OsKd}{<`tO!Q9;4`dntTp~Xo}5iK`8#?7 zShmE05RyRRcd!d~K)0^DV*@C1nyBiAXmncV{_(d2(!Ik?fO?0c2TY6HXag+G?E@O~ z$h}#dOO-t&?1tsYSs2&JA66$0pv29ad;)(fR?Qc9IhKSWntX5Gid;Ibc;oXeFyE(% zqJ{(ZzgbX(1}344TXBmJfeiPZHQccS*Ts%_r%DaV1J2b>K#cz+?BK)7nl^57@)(wd zyE(rVA(Y&D51@ftp0}$7s~*t$&wD5hM*fClZA_b*6#n-GO<92$P(sJ9$>Eyq+rP!2 zZDK`ESnHr3WQ~$vdoO$ludLi4B#E8YVWI|3HD!veLu_2o!1KMByFD`04O&@eVNlfF zKTA7czC@Gx#`?iq0kHI9_#)Gim@->R$hj{B*z~->+<}P~0a2`LYpVaD3k2B> zFRs8jKJE;+la%f`=eQ<%S|@b=boheA^`rNcu7xhPq$%?CM`^!+#gG*467+SI39qD? z!pB$lGMq`v7a$3*y{ZWF(24PhMzLoJ*hMU94RVXS-~vkv-^y!Xy;qDZy#G-bXhZb^ zWtBCM;tm!LwUHf`{GL>e_$owl7tVM0=53mSMZ63^JbAw0R*|xk3Dl{__~?UK2KOh~ zU_(EZlZ>=g3$SC*e{J}?d2KJ2Q$*SErKhM{{jev83%hX#`+Mv@F(?0t=Y(ml@rcaJ z0aEjE`W95(YQ3D@0FzW221`Sjq!)^X1-S=4bVN&0->b(9i1bS_B?t9IXF1;kNFNqW zP}SnwP4_zS;O`MeRDgGTaHM!N-Vyjmfav|T zZmpcm7UMg>l%lGk@R10YH}`@z+O-{>#x4Lid2k5yLUoD5g&4OnIy&|I^j-gBEphKA zDg7Uy9q;8%!)17Yw0Ao4kI9)`fX(i;S=i0%>x)!mi+>ccWKgjnfOy)z(jhJBWDEYA zJ%h!*j4*XY16-3#dzWDJ$ng`$iY{Df8O?pzoJ8qYe*~B!pe8b_+KDFw@k6lxBppl? zt)#V`=)=_#!+y@^oooPYQ>&yWvH?wSe9V_b$jbYY6GTlkDrJ$loE_mGwdUtZwEdJ# z9IU~#;pqn&rDX;4`mgH8L4tB%MYU+mN#$>r8g>?O7MH3{nmdavI#=m5|x{nY~9LifddCn$P!s20JV!D8^-x+@WE+BG}lt z2SEcx9~PE$pwIe|G@^W$-R_H2Niwwm9EJAi&1+yx0kr&?i{})qA(9TDm5N}3D(=QQ zI4m-dEgVbi2RcA2Vk_5ygC%Fj)W-pLIF|tS06~}i$kPvSi{MA3(@B-_xYt{ZF-1?1 zKA!nH*r#4-##6`EG@$hyN?AY{`Deq)oCqh-YTRV|ku_Yir<3l{X`&ER@uc*Gr2Ah@ zBsz*CINRY?ziIek8KjToK5_UMsE1JpY5sUZg&eh3L!5FXpPk(uGNL0jZeGdpcnD*M z__I8c+xOqOp`u89Iom=wFHO3zGcyNGC9y-gxFM%dvD4$AJB-VOOsK0x_vl}C?MJp< z#(i^S6H=(?v)D#&$VUiTU@ZPHW`p|~oA|x*(<>$r!7)AP=#5R2Gj%v)SYaA~cAX0N zHhLgr-TAx$v#cn9Sqc;Zx%HPpV#b3`T{FPGyhqTu>{~x741fO;K_Zv@7A3qx{^Kbi z93?J~+#mc0YX#r24#!0MP=-b6_Fwj<)C*@B!1II=PR?dxWeFv->te5U`S7K4SzY^#|gtDkAhxc9ee>#PVDMuVO@2VZzT{XV*Dm4 zzx_(GY+;L-)@e;B=m0vPXF+2oziH44_RJvQT>4fxm0GPMADL^q zX{(Zr=ndi#PZloEiTSxJ`dd7W|0_5>2Le7)RyCbaThtlr)ypiH{wcJ@CljUcv`v5_j)!dsan3rZCR} zEWyYxnT1#^mfT?>Z--GkK2%mh*jks5PK_5{>An8jp8W88ZrRA?RR8uG!M+uR^W8Ag zDv$j7qh4L~Bp)qf>uj-`N)MDv>KJZXmAlL??|@=9>eY;{5y!QH9W@qjrXd>K=0{C{ zYE_N1v{w4sItz&craa`qP0}(KhU?v4#If(mT@-;g-bhC{^VIKl z9--?E$zZ}z9VQ`d4>ltiNp59UE$bqf*xJ}C961xTV3ov&kj%B)J&(u|$p#PM8f<#W zUGYd?Q8FZSq#p#QN~q<#tdG)^p|8;)+@R;#zzO^aMH~lwGuMBHpz7RdR1gc8$gk9` zYLk9D@Btl^+RCqA$huW%@#9M`m%Fg}D;{N-RoJN-<0|jdH*fjbl~qw@8CZDlIzBvV z$18b>b_G>o;=Jqd7V9hMdNGgIt`6KT>Cxc!W=RrxJT2%Ignl@9#VQ z`8L$*C;txWRYNGt=i&nJEJo|?NV;m$*0rw`7U89ZHaMb7 z|J%Dq_`deNgqJIHlGXYbwSKg6WJRC+wLkR2u{x;8PrRWBK>lRU z6x^dMFO|aoB`|OQMrip_>5dgEk1@H^{`~@2rTT(oL)P+FG4(It&PI|@A~yW8L&b70 zz3l);;T#lmFPSbNzMkzZ)q`c6Mnt<_23$HvO4C^(mvKQ0fyANd_UV&R-l~%kdm{e4 z!C{+=fI{F~2A4o;&}+4<%)VbSs#;Us-7LxDZQ0Q(?^&%Hmxh&`*~c4ttZ~p^_AaZI z35K#6^QJtkDLIzTjjG|Swma3lV+%joYAe~H$=I4@koI?Hlk_Xau{X^H11)2@gHe|cB1ZFE3AErYfixJ96=GG%h&4JBYfix#>kEBsAR0Beah_Iol>cN6{wO7v?P z;p6D5EIxW#mUEQH5)EP+)Rt(}8_5w*R#r%Xh%V_HE8zu$%epr(t2k-8fGj*a3tmPN zziD??MnW5YMou_)4uRrm>OAB4qvSm_n?nV)wvq#GnLyz) z%LR46!|C3*0<{+pm{E87$S`6x^Howw^suP?f}NB7l^`H40@P81-va0llWJ}PQIZcZe- ztp+|U);>MmZY>%o7jsXVJ%xeBXZmEZ|9sGmmfKQ*1;-I0uvD-x;Mj09VsqZxuzeF! z(>4CdL)h`5p6JCQ&4ce%>vibw5$nJ!HZ)KVBqB6|Pdd3?{Uf{OKi8&pwN&(B#;*!3 zvTjO5-_`?&44n^lfL~729gvR&kq{Jf1iL1OJey_48cGt*ICf^#19%wP5 zF<9^FPvgFsMXZrghHX?}zjme#Lz)sk78k^jMG}1t`^thR z`w0$?+5+;=G;~47(1g-?EIH?4huCZiJ&{O;+*6zwqU9UbEbR#{sb}ih-AP3O!Nn}^c*OPp<}s#2h8nygVsjZp5Oe5qY` zK*2Fs^EA_*mW8cLtA2I=O|1rTj~>AzvWe11t!IRjZegM1{EEUjL?@|~3f}b|=p6sa+ZiNP(}h{K*e;pf2PPZv>En>nW2iJb7VF@{&UOdd(dP zhMN|*VZqeutee?n-ZMB4>%f zFcqCe5hby2+(z#b|j~1Wn7vM!ZF6mHvy%82X8p7`Eqc~Qb@89SFdla*e#iM_De!Fqpf zC%q`B&!5TxI_2apl;m)nnak#If6V)ZJ^_Cn)Y)QtDLd1#$=jp|AP4_oG2NvQ31rWdP zHOjnNU;r&7$m_O)|L}Ehxspmw{~IO_yGZ%uLvl<*Il!a#!uCb>_!LqQ$}us8Fm*FC zdT*Bi??!@#aK%xF+`tdnk0+$@qrUyHEqkCS8Sl5Tx$EwUSK_TL-7o&7oTO^|&5dIe zWINB&-ywjU(^Dqw`xALMr7!#SpZZ%-crK)cG`4JR|Kjq_z}WIGnAsE9tMju~KwNaP zc-4V-L(@}z1P;PUmq?h91G+FphNYT)MN?- zZZy*%o5&wk=OVJZLJuO5PBE}dN}o$oV;B$-A#KhMIP?u-+B`<06A%RYcdnw$Z3T)9 zQEGY^xSx@MxS#_~wlnCba{tYxx->wQ5%2xi&inVW9}3vlGyFOA)VUSSe)Dmuf6-j} z_V8(WfK4L9b6=U~2S))BcM+B0S=1= z!=y5-mbsJtI*pQePz85h9AK?q>WWm}GXav7z%4NnWPo1}t_L2a1mMNJ4c6k_AD4$w)0&#dy%8b31XE=}bM}Iz3Q-yhBeW*X0}D6yotD zQ1j{1>dL6KR3IA(%3eKp7M0z0dg0Cp5&!mnwXrt_H5+9j(0KEF$QTc11Tzw{V}(-1 zcl4q`os2jL0&Zc~0i5)}^OFG94i!-P!6DvvH%*OZQWlrI)3 z62VMuL&ksP8mMyIi?V^BGT_N!xN({5C=b);&ore|)e}q@AJ(_o0=U2$`HAXaOYhM(S|OS)3?Y}x~Asjo&lYb!%E;lT3W~lsbUuS?EQ4g9#mcCrn*&4lm(64QD|x&f z@aQl29pNnd#>@^_6>E$IzP((kgF7GAM?UJIjRJF^qN(J8_0)nC#rp0q0G8qevHqs< zsG!!qrKsX~qoC>#_NDhbP73KEVFYHyM}!cuZZ4wlBC$ecS(GTenW_|YrIdR=*0G$@ zsoD0m`RJe}%1|eS($GL2$ko$CZees&ecskef6(6_wT<|&m(=$E9?VjpsfG~^UcInIhX z$R zPnKi9eTvudq|`a%G4ikg2NA#G0K4|pEy%`+=CQINHaB1STAm!AMDGgsb2&eFX6LlL zQJbju-%3sjsT~>a+FU5Tu5?YZ=O2J_e$$mJ_Mp#DhRQD^=u^h`d=PFHJ^)v2ql zdVi}G))0>>$Wl^ZL_OV8&JxSEwPTzUTSj{%=jJw~%=f(cto6iti)~UA8M^k?t8phI z!jH8m)v58_!_Poin}<;#ta_*U$w(2f`_nT4nM{jNyH{dcBS4Q~nqhcS>%41cMo(=r zd4qB7O2Zgr-2v5mOO5IxLG))=hFE)4)IY;MEM@*!P-^XfW{G4wQnb^>I?NP8ST~?B zYf=bW=zMI9j6X!Wk8Fh8Z^?c~6ceWQNS%c`wRGPVV3gOJbre9vmL3wBS?WRk>7L#U zX_DRPPfbsvz#DFE<4P^G_*#_p-~1$wwp>DE;|_!f{>o3gJB{b4B@a8Ji@nDeQt`L( zeJ`PQG*RJu$mT&{75BuI2*?rb28pOYX|+~)SM&y(H>0>zV}!hzd>*r1*zdflP9WHg z8=adSajiAq#4Tro579(GFVJU`bK}%6Tt@P|C+K<|(Ra+j9AH`_xuXj-Wo;?QF_F=R zjZmGQSWh{_<@;9{Hxl~+YL$~!&|couXF#?X50hN(!)MDQ~d3_9ct2tN$NMr)3ldmkv1XC3~rck)wqIFqt2wEKDo<14iTucY~0XPg4JI!EMv@Tl?EwHWGIZ3$ZqZr!F$ICTJSd*v=Cfux+PFPtm*QD;fx(i5f zz6?ehn~oyBe5a3&mA&=}GAUTw2dWX`ts?NK$hG>O`KrlWE!?yUrZPl_tAW?DA1bEa za^idmc~W*!cn&+kg6b>eLvVbg36)&M3*|kO(!Dn?MBINUNSIW?ib>huAdVu_1^CP>_D1UCqh&e|gS~ zUwP4|@&_nZ&!Z79FT3SUESX~!3UPj{DM134F?=K;6Wi7Tbfye?g!PXgcmq8GqCmbz zxt(P*NxWk3d%jQ3pk{u(AOHOI8h4~YlrSzeEI9You`RQYK+@LD1K-fY^taQ}QEcgRqITtb}5%j)Y5e|!dyPL?9*H*Wn;MnWv8m%PJgrhaRpCn6V;fC+$Q1OO{ zx{^te*xeC^fvVxni$Jud^hBd^F;&A&!s8#8-E5!T-$(ANN_W}5dBXN`Bq--Nr_h$1 zL9?WKQI0#48cvPWQou0(l1;W#?1MIY;uuYonvo64ZR#s#1S(96!sV|i1U#LeLM>K= z6tUb*`nu;7>taauTW|*@h;>%^-|cHnR6|%CjyAfz0zm?{U<2K5(6*pD+4`RsrM3FX zfhs-WEzszpCjmU2OW{LH;nkwF#Xu_KM8U*&*iTyPv0rwsW4MJF@oD5el#RPOnpsSk z35@%b%5&#zl;75hyfP*;>wm0dGGk;nrR_EYdNs3-g6Ch*Eh=rb?dK@&@c#r0z$oV= zCSXMk)X;VI3s-PgMmha8s+Xa2K^JJWUFX-ciA}(-T;SCS(^p) zk|EUkiJTeqjj^}Dj@$=MNLNDO#*3*xd$WNma-D-l2E+Vjn1qnDFCZpI#7#5;9M{;; ztX#IuRWvFx?t6aOc(lHBzT%&2kjX=fzdFjfL)?$>e^9o;kQk@{gmq*|w#4YssNYmiO|Vz41nQ z0zPT_18`@Se~kz4()9vsFbbc^(6M)jxfTnY7xy%%Oi^XBV<5^Y;}Lz_%)wGgv$hoP z{aEEW;X9Dl`%P~}a|8MMm^cW_6v16tb%)IsA)SND4#!zr=@V$Q6(ZX=*2g3aIP)<} z*}X|@0(}=)@clUJ#5`qmkcoWSywfaozt-G5683mGv~iE8DZ=&;(JiZ%w#)*_* z__uhzy^s+e*>~=2kmoXgs-^R$TdzA4@2$venZZux)dF#O$mX1E_Q5rTWjWG9zTypg zNOc39ze@ejS9&#wpxccli_N<`JjEJ4q+B}U(*jXq6~=dc)3(j?PA!v%y7pf@(vYM> zI?e9UPM6Q6{!>OOyZ=9BGy_~MCG{UeTEC#1r8iV;@WpphI6FBbzz8!77h5VkNYQ|M zjCi*RgFLj7RYFJ;lTRzMJ&F7>rUfm#$v}saP>;3C^#&6;FNKEaI~}(n1BH0I(;}oc zt99dJcuJpzU}tNmhLzpaUd$kK_uap@F!D<4Jz#m8^R1+w%miMCn@ zb8=8EJa|ZI8ZeMP%t-yoC>_?wLhNF|Ek|590&G>O)DTYhzUW!+eDQgjeF3Iop7e43 zDEZ2bN4*o4*jv(?Kap)_39N$e;^EhOhf;1Y*M^Z#BYvJ~gS(vc#@_(302(SYjJomB z_LHp9s}H4ih$(qvR;UYar4XuXLBN;?P~QOA(~6;Q(4;TN>BadmR5pnw1{!={ITQ`z zaNe~{cUp-&9R*xJ1|fFnzC|*yz)D(W`XQLW*nQ1*4ak8WzelW>?(7IJ_A5ZT%BJDH zmy#ca(;%fvSV)ZAur!PcPmW{g%lSzgxJIM^_^G!0wq(E*AY^+CHMgXs#Oei_h#jH{ zcG+a!X#yh@wOydWDlgYzbjBs=aOg(Lk_Qw;GGu(RQ*K&-KnoMxgJMwvy;@fU!tS<~ z&E1Z>aXwQUJsmFRFF$*2SoS*|W${*bNxL$O{-8jf#GR>mmpWy@E=2|96nLH6hv4g~ zwJlnrfuvDVCz97?>qY?|p>yh&DYfebA9Z2O!P>mzM;{=MIgJWp`8(Zv2uLgG;0=Sne5U62? z*O_yGbO(u__S#idP)G*P-`plOw4(nH2`n+)|N9k_O;dzFyz<9{J7j@&>l)Hk{(%%J z>AE%;{@CIjz=MVUR#j;;6i8LX;O4S<_Zo$%c?d*6Ae1iC?E&oM3mUq9c=6_i__-N6 z$KN(gXp{Tj052;NI7cSm?{ARfd(h>rSyRmYyg}~j_KdVYv)G^ek-IG z7#6qv;+dCppz~_^{6`PMvPVDOz`t&UfO1Y+ZH-@c5SGCJbQ)Dm=>*4JGeBYs;1XO| zF6m|mcZC!&&zJ%AXbxoW(XX#zmX^Z1m&KZ zdL-@RurVZ3BjboIt?2-(`a_RYJOp*|S|*lUh|s0X56sJ6%SSkeTRI0C+nuDR~$f;0Sl!avfi$pl>7&a6(SM?dIb zB+8FHW1t9TO8VNg$T808gspuq+b@SiVdnI1HeJdbgq*5~?yt=!of7`@_ET7n@vZsQ zU+#)VcB~EmPzx@p0+i*2uNx5z9T8#E3|Vy^jsLipaGd0rz23|kIsG*zE=B2_oUcuO z7aJ)_u%i8XScW>oM*YG@9Y0;dFqox+`-@Ib4DZ72YP!^?A`?dAS8k&xkiPjtrRj^y zouVMCTr4}JlwK%pPSe;Vr8zyF(8L~;i}Y}l?>c2&+jfPDYjnT1KhxdZSI}Cjk)fER z)!$;pgKMiK7|Fh_t@oRwvfGEwl8+c1VE@JVF9>hvy8CQ)0ms-IoIDK!`+THHg@;({ z+ljVhNeiT@nfwp{hOG*keNs^H{Refhmd?p6{dUaFU&DW=tCOMp~bDysd>cwm5)H}#XL^;{s^^^&Q?bAaCeDebwUnq0d5k^l(-0!Z%(h#-RW z-hwEoRFQU&-a)C-M1+qfAYHm3QlxhkDFOx%LYFR51BeDr5Rk5vn{(E^>%RPN|2*wk zd+jp2teLfD@0s`TExE4r%qRCfJzBbxRMP?^V7n~Acj zgmYtincvgdss`h6qzku)(G(4oY6$v+^hi6TatvlTIiqY?#vl%fLA9*^Z7-4exlGKX z?h=9af5}Xw?U(w204iv>ejc=tqkCIJ7q!ftvZ$XI{f@+Adzx)rH6%mN#nN@@8>jt=PkvXwL4&HEQ7r)oP=gl2PW|*-B2Cu$UjOA(`Y1NO z*CR3`8!?M|y?I^E-Uo$t=mC(WZ5&(1mm#EH4fJLZ53)AcGAN=`O=+nU{W1hdR8>{A z-aABK7;*1wYimREOq^dNyV~2pb#mhr9NFdL$+|y-FzcHLEt)`QlE{7Z%QDRK?3En= z!lAbff%fPM34c4FOY;mCWY?mlC6ilT<1aBsH7Xlr9>@4{0qk*f z^b4ACV`|cB0T1YGnfMpg7;)4js8qtV4x#;Xzt_srebCA$n3AEyrk!$m_{TU`y+mwr z#d!yxl>4Yyl7~VOg<(#GeHH&c&MVhQ>mJUCg7yxl(0#7-M*l|*>7iavQ$G=l+JZRs zmi{oJYnQ#+eVXvw6iqu?boilnvHu9MkPvIvB~NYxKDbfYQtE z5E|DB;5S2=(1L;&s-TMH2_TU)gH&uUd(Q(StzK=M6^P0z7JG9YJX$gMi_udUp5 z4mMm?FN!%sgA6ej%cGQ2-iX7>JtK&d!?2uj4{&(WkeuK$GG)Wwz$PbdF6b3&)|u~J zppfQ6&kly)H1c+>&(gY-zdK+vG4at+szuvHp>P@FrsokM>QLsBPgO`immv4_-ZL#TeTt-*?$0(WZ`cefLsPVq;h`714U?V zpc_xNRxCJL5YE2=_*?Ml$OKM$eV`(-gqgCwB?R%e2B!OPTm;;Hel;vB0F(8Yc-1T)(#o1p$Mb$A>ozczQ^{}K z#2&3njUE#)zG*R)&xqwTk1OG3U!MC8u(F^Cl<;WAgCaQXLhO?q;2FiT6mAN0!dtq1 zWnqPb;C06WIS35!_TGier{$u{5Vj2I0IJ~CS)G2h5ji|3R}8{lUF~P7=fu9WX4LUu zse)Lh!g3n@<|n88U&73F6+kv_=Ii^=#TE*xg-G@Riu%@u7w@sI-OKmHlfaFd9Wj?v ziQOBnn4FN8NJ6UQi>RZYRTsbc`a@vuz}z;CkEk|jm})e*v~p^Q(~OSLJKmx2)11mX z^%raM&k3|xW)linQ5Qlt(r||l%c5+@2!OS>A!4eA*g;ADq=<+rfw`7zljQinowG8J zWtDm)b(2^qCC)Y;{?b4BV*<}OqgiaJq^Ng>a3xYVYfwlqqheGQ?yKH4x!CTdAvZle zO>}qi5W5sJ{l3Y}Xeo2Lhk#6cwi~`4Kduw}`yuNM__|KynBeN+$qgcZ7o?3q_&D)l zfye{WzGCwk$e<(CVD=2#c=rjXPQsu$&**_M%xlFkSiaZM1E4vyP9(}Yk_NUzK=!m#2 z&Q@MIAIsFriKRDbpkrM4g84&B_T=$1Pc8o3JN4gY6D|g%3uE}cb#QIAea)^O4aKbs}t=)kr}XR`(0e&5o7HQOJbl|b3I78a+nLOxSZU493@JfCgk zYfR6qQv^*(Y`BO%b?|x&%~0paD<^>KU09Is#N{KI<;vZq->#;E*~@^%GLVUcD~Fjv z+9bRN(pFB%+jY`Zd+V$=YxogMXPM45zo+Xe{g8LwcVO jYNTqKPn9npw9i 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�JpESnWt%L5Shq7z;VcV(pvSy!P`;8_CB=^xt)DO{rz5XO6IIQ$ z12#zmYBKjLX_4-K5s|>JCOm47e`(Y+pO-;B`h5w(V^9=o93)#YXp{G`WS^fXvKCZ~ zSOAU7I*%HLa|Gx|8U-@JzA8KGXb@>_U?PA!QTQUkYRIv`W;^OYhXaukOn`FuH3cP zd4{?^igH}G7Uo2oM0(Ry)iZ_qLgiBZv(mEwFvh-1Kf!CfvP^e%uK3Al~6Wg(Hc6cCE zP6*eJJ~SF@bc*=Fjid}Mq&t=U;|sYq zoGi~-X6QnPA*6U{#8l|};Hy-B?|`XUA(6+75lSj-at zwnd?5J!);-M>a?7?Z#8!6&}Kw&yasq5X*>OaieHhWR~pbtdYBcjAMSH;50-5H zdLHl{l-Em~L2(J#t|kGQ>o`%=I*L$t81;8;*J>T;$8d|RSeRa%snQ{sTsql9%a)db zMNTMAW9p|Gv1AriU2C|Lr1JgSa5bq{pc0G|Y|-ef?Cd*t0S*{_cPZ=j+sJoPcn@6u zw)Bw!Rnok+@$gy-I-EXfuMYi-*FBk%R;oGA@*|K#zK>Dj7`3mq*_Yp^Nx2&4Bi^+qdu6r0{Zlkq%??oGZn2tZyulwR~2c4IQh$J>C#XR8=E2 z|J8Zg?feD|MQpylW4TWSUTK^S5yTbDYC zcEK4c+1$u3YtA{9*&GkKzN+kJ*uCsUu&Mq%-e_9{PzM(JKT^_)6lAW*h;uO*4$d$e zB;BJWfxb)b>n@&1r{pH5>rdnIV^|6wwyx`nA=C`}H^C23_QMX_!*d7TNcz$ z^gjCe6g*7H87=O-n9g1GGCwW=-~XwW7F#ApLeFv7>+793x5;-$cGz~gXaYt#qRFT9pU*64j(R zmpLFyY_QSiZs3+G=Qp)vTB+aKP3Xj>IEU{xC4?BoLOP2PuZMZ^k54dt5%%=wD7)aL zbw&r!vqKxxjsd8o?U7gb&E26V_L{5QG);3@p;82=w|`L!;NJYobdWLh!9gwsaoakj z@^t3I3*YAoJz1SNiC7nEjPx0?0vwHSln>zB?Me+?d^I#8g-M>g#&>x7iK)+KSkP$0c*l3|hI zX?sgt(^5QWT){NVl7%5kw)Beft0G5I^YoJ5@Cb}|T6^vU2tGLbQ?GD0Zef;daM1^@ zwItphuY90=WG~l*1LWT7PV4~M*~b2STMu@%E%ucIZ~=Guu856eqlK@>z2Fg2)9_%N#%;;xJREdYKnEK zH&;EBUJ9!J>3wEphS{T>8>;+X$ORl;OL%3*WpvXsshK57gWj8QNSXzYbQIqY916oY!2l8l$_k+>-#(D0MZL`A51I3xX(WPdX&48gO5 zN%F@J1mbaz5fR?Aq*x?FR|YNoHMwK9W1e3d$lPg_S_GhmJ+LElzmeXu7j@OeZ3IWp z)u|VF>oKu)E0{_0g7P`tXRa}JmYCZ`!w$c3IB_;ZbGtRLk)WeqYP2qyxik@o(=$<$ z|2E)i;^3<I!r=1EJ9Ho{IkT_#&VoZQ04P?JE#WI*yeLp6=Nys_V zT;ZTErkJ?9yHhOY8K9GF`EwQ_6v&8jKqr}&AA*psAdIwuBI#MPTn9ZF-tn9K)>XCS ztF!!uy^2+m^Hzmk@3G>ZQ7WC{cjMuq8yeS`xUobPyUVt?3SB8~W%aBorj6(2uoq6I{ zAX*o5S8#%fn=J8m7F`H95^|Sl z@Hn$(q-U)?eoq>V5#kEw#xIrGxWfG5;lctI)L)}pEk(&e2PG7)ucyNW4H{0#-V(5E z7{gD?SH>SeSw|e$OdlBkZT1&*w&qp)AYIW(QDota#S&F6pMnF{k{`yE!Hq+^neQSa z`9h%PSOhL=j7a>SECkVyTC8u@Z+@U@NcG_=0xBEU!a5%*IpVGTZYt!>*_n;zQe8&D4e zxX0%*U_RGgs#As&EAz*J#F<CR?;;Z_!(uqW)5OPdlN6JoM4q%-g7YZKy-xiw zQ*m!cx}Zu+s#3<4(|qWAogh^e1CPl?BIrPzp&W;Rmv3TBI!*TH@0cC1#Abvy|2Lpx zGY`yucf7lJ2Pk5u19uFWj33kRKRIuT$$hWWGyAK4HiPBx1GlZ>WyXvQA!qp_fJxGb z{@L;r-S8EtC6rCGq309!Em(R&M%})kuB4thqUwOg=L|y2gsNpDg^TSsX!DQE_wumm z#eh3%bJWUIV3GadIjxZ7`TGl*kA$gUP;(Y*(e`#&-&|lH{nEho;q4+KZB*p$#MSO@ z>2zOI8Q1`eYVB&^;f?qw{k62<8M1;M%TM0UeqLIzU6*JHuRuPqO+c2v@TeIp|I;NB zB>&FJ^XB+q*T+r3jOD5VvfG}oH@N>`CE9+!VZjD0S?vFfN-H7?)6L4JERKxLrVMP) zzb;)wf*tShu)K@x(S(OU9RIj?O{*Eiz}KCO4tZJuJtN=R+|wMm<(LoHfyT_CQeLdD zHb-o8gbYpkAS0F`K0Iu7Q2q_LbupM^m*WN;H92htkP32tmAgDu2ucXuj?4&k`3HAm zN?4DJO$R{)hu(%oC8h6j0Qd#Poq((aNu(G4-6xV>lU{F4a?VhKs^*#nl<>eWyx3g* zozdPWU`fqHKXe$4+f&cN(-rGUI;$>>iw4m_8qIX(}L_ptYadEddI$ojTV zRswJj)(B5fiA>9g|16z|aTpf^K|$cWpn)GgV2W+S#aoWHN;;0fGH4W@%T3MYGaNWT zk~+XK+32R@Lv|~m;c-Fgp$9Em< z-K#h`_iUC~hyMG3Vz~b``WZCw9`VVZOU*Gu&|=a>7*Ci8;~R%5%qbehTIbv_hJR*0jS^2}@ z-Vm153~i1Xxwi9V7Gn9GeLJbn!)qnI*vYsm`gxqxhjv9&j20SqwyZNUTfHvz+h5Mc z;oyawe-)~JJd|N0xypVv=8i=S&vmBL=IfUQAez=vLxUdRLFjEhQow1N{h#&7Sxe%9 zXfsBvIIc1UX9VrUUldJVGTfrnq191B9r@Wk6pZat6ZLerRPG(eAv8Y&mCd!JdfC1J zh}q@T&>J#w>?@fBIrM>;^5`IT0dDr@jSCPR&58LSMlH5L{|A+R`i>9zF2|K~k(*Qf zES#?IWOpNPy6ZvfcmzI5Y}U_xSpw~vgtu=Ql8bw}qh75mVnJTZ2PG4nFR!ng*XM)u z8|-@5{{Ce7txY*NX>->FWRzn{YjuUUwfH9qD(qBGwYZs8$K_(i5T6J!F7LhByR+ee znrBiBOYCw%1+_t!x+q~iogl^;<}uu$Fvs{Ob7f^P8-WJMy5_k7_j2r4&kwg{033wO`1$DrU#d?Lx!ja9 zY<|5jE2_bmL;bt@(~Qz(WuoZdkpeDfU-VBh_B(VzM!^pUf`WqVFOou&>bYMBSd_Q& z4YUYR_u@T`LoGp-6x|7YRlc@_Sv<&iDjeosKsbsYrl#onIhgD5&t8ahgqGAT7Y^ZD z;WHe}h-`8t@`GlOW7kEhK{WXmLW59SV=2RC_?_oMAM|iDOHU~@`faMgXAzI((;;O*0QGbj=u$C> zH62&G_*53#LA%8TPTvYipUnB>n=w+=K%T%@mVn7!iDz!xn=84z<2_!iH7aGZK-4x< zv$SWQi|(}taZ0Ivp15!22J~g|K?-RGQP&3^zL9*quN1(d6oj?Mq+jKtTHZGiT-jpN zFB@%dV-{CR^JME9@73eAsgw1KJN7(Sbq7yD4A#vkMo^o zn0Hs2qo^if(UFf7ku^p>mGJA6Hg&}X;g~4&N80l<^O@gM^X1(LS};;dbI4!g1OM`t zg2SX?`Slu)cQ~<}e5panJ)<7_YOc7ez;#;{oBQB~EI@{s>GJJy>lh@EInqD|Q|fX@ znPaf?c(-uE&rWK0q@}tZY*%Qvk=h5d#p2o~|G0=0QsZB7PwpOj0}P1*lS|!_O+)Q2 z#hW*e;M+s3D)>)-o{bIful_S5f?zFrcBMMfrK~*Z{eJOhG^rv>wD{GekrcI(Zh;fT zGj`QLeYPL_z(V31PE2{_m}`J@35d0IVJp2XgC+QO5+IG^(@{_q*bcHZeg^UF+l+DV z3PDjh<$#;D0b^}d6_d3)gmD8f$J3qmn&*AXHt@t#MP}Yd{r;ijd?o6G$05ST;vO$$g%h% z;eTYz0IV?ze(N!l)tz*AY}j}DmW|J4zYlu{tuXaD{T;oAwwHL(bBtgRoLkb*PY-Xd zPuGEL?S;DpVDSC54;73H+Wig(c5{&ZcQoOE5r4xSAwE=w0O#*d(lFbDURl6slqzRP z9UE5w!wut=uB~q8%dP+oIQ( zsXq+_^FY~jgBV1H+M|f4+pK@3 zN|P-K3ca%LqfUfbem+ZsZ+GU#0^6ESLy$%7_v6MmonF*mNs~T$eHh+*t*JnLD%S); z>Qvtbg^y%Bx&X&baeSZA*kY&eu&BA=a-;_ea(a51po}68L-BjO#vm`_&oyfZT-IE% z+QB~;R6aoX96{^lUjT{00$b(89P$mnCAY+6pDun)oTH8`QOtxK9(pABuW@`p;ufpalaPYryM#5>$kAgOaJEovzCE zj>=Oq9w5N z6oF<_k^#7N>xxMUZ$XzNudJL9%kQa22vzs~-$W^p&QxfBS)XU!Zy38{!lmz@lS=wz z3TRdT*DYSiX`<@EewA`?k%HU$zg>{M$qpkpotnJ^iI8BDy7H+pwc=}6+u);s@f;s0 z%FeY5H~zv9K~cn;X%i6e#mxE5Cb~PksRkrX1QEQKznG`zTtldm(wgW6^(<6K=fb_t zja*PwB~vL~X6=fPNdNhi;gen*ou^L?eP$dIHq8Ts7WyXf?{-X~6318n(wncps>nIU zp&EkvC{)FDhruDnw&P(Yvw&|@^FUFT4-fzKGCIX?0=>WAkk_94p{|*;VN!sept7fm zIF87D2&O-8wC~O(c%HFxZNbvmoE{lMea0t73S$yw|315c4w7XcT}6oj6PG0DT{Xyh zP0^Ag{-SqL4r8vFq)tJOFV;K&kqIoGlstpFS*BniMx+V{-;}c~8y~knr)uHH>-N&v z8W^togNs8ZOI8hf6uKcY7vS(9+nPa9i-+%p(mb8ba)x4$w^<22rGwkvR;IzMeOVP2 zw9s6?VpB^_WXPJt^$Ekz>eo$vAIx-e;?k&wS2;VzeR?59b;tEAC8rT72W^Vh?VJl(8)Z(`B}IQqfpuk!ofM z=gwo!>2I>%$2()K%?ajnSkK(vQW(Z0k~LqyNa&KqIX7V8kTLR8H(p)2NR{;IY34{! z`UTD;MmdcwC(7TkcL|FT{%&H4z0zltfa7}%|4La+s+C!;`btj(tniD8B-&#Uro-(? z_q-d2eraR}a$+#31Jdq9-|k~D$gwWlPyuUI%us$f1w>(Jw24H2#&suT->+^EZ(Hna+`oc<~eBNKC zuUPj2&XK79tgfd@IbF_G68;v>r@n!bent4S>hGs~2STZSC~|4t6xyMa;Vi>|h~T4oAbKOOQu% z^I}4tUATIOg`ju8|DRqC{RKwFZvoS&RvLwGB=9ndC|0_nsIzs%Ruo9_+##Rg^cMl5 zx_}}FuV9TZ-ZK%Mv<*Im?QofR9%yjdFrW5BefOGxK1!g;?GbTJG+cjrcLV4Xvu^)PdZvkE`a)VKBq#d;C@5O=iNkh|g|#gGhHacI?P5q5gV$DKwhdkqm}K ziu0BealEyq<=_trHYqoJ<)0j+K%|Z94SeG0K<=lmFFFOod~k0=y2XDIVMKOa4X+#@ z%((+3+VcX?vnop0YiYn=&Iwy04RjPdXGzeGC1v|=_4fs+T*X8|dr*ZJ8!yHPkrfB0 zj!wasU?rmGb=W|6f~I8V>c>hJU{?3t{X_D1?li#+H3g z%2KvTXp}wvjis?9jV*&j_GJiRY=w~QV@v%l8L~veP+7_@A$h0w%lqX$-_CW;b>HVc z&-I+^e0a`%zVA~K_R;|S94a|U3Aolss9*yPJU!vU&ET9N>8g8f7 z+v>=CVSGHuLM8d}ncMHVgeZ>ZR2T7@zC~Cfv*#?JDspos1{l97$FAm}5D_#h(Lp@U z2YiU5r}fgpi!ZEiI4zg#s&23+!@t7}WkP#uS^LreX|!!soQ@n>{*@Oq=0ucyvoi`7 zgt~pBKR3N@R{MDC7doU)2=-ELU7gT$tDWK{3A=@K9|itImy}H2LCytwc?mOutLynf ztuiHSbIi9kjL(8XJ)mD}EZcv<#ZmuI7uVKmIVs;_r1~@A$r+tFejO$-EvZG|Yu3If zxs4@VJxiNGoxs&FS?Tl%x?Bbl!h0M{W&V(f)4~ctqX=B;PzypZFy4)wBK;d96zgZh zRB+DPxYcTH<+MZ#o-@t}6);~%-Nl{ZWH}vGb1JSX4~CQEr1tezTWy|EPEo&>k(5G} z^ZPs%hXVp)2Tuce7HYbXDP_VaF{1OTqavcF7)A!MLbb4wCvlp$=3-F8(g*5L! z#ex`q0q!hF*1s0|^?_df*(>iC7EN?Z9%2p!stP}pgK6{kPA2rCl45cC`(h(0pP=Oz zs>6|l;W%F!CRS8}@b6_?rj_(ZpKCewa92v1x6Q*XIs|oQf-0v|B7&^ig*_2 z2ucv%n7pY|G}X=ki^1;pKe?;)g?E9i^CH&;YFms*j!Wgru;G}7z_`J!ZoS?$H<0d+ z`oPETgG9ZUMc@;MouzMQ*jILtcx(fw-rZ8^sc+gvp}u6Mf{aP&G`#!+NLmS6sPjD? zwEHjUr5ui2z1Qo#2X#R6>JbqQh)o9f8}dn?n6<71x~!YE(^N(Bq-EPm!r&O%*fCHI z>rV$N(6$m~_cjA-G%LE-i!_q?sLiqUVYj!R@}= z0WWc#*CvCOH737Nh{uMpnh<;Q-vU=pd+|YOg7=iHmVHlMVVHa<9KS#&{u4mwa(EH( z4&Mx{RSoxYBt9)>o@-2N4BjEa?R$2ol=Ng%fGHN7SP>ts#v|zlsLh&$ ze5ws_7fo~ujSfpMAnK_223Rp(JV)5nK3ZXOV7gr}vO?X<=cL%N{aofk!8YbSQQQ?2 zss8K=l-DALSAm~pBv0KqKF5YfJy`kwN#pA=zuKqhI`+zMh?3037O^fcYWQxR=VO_+mTXxUloCHHnr~ zd}if!1<>g65$MDA&o++NW7i>24b50o>%tG^mY1c|8R!NXL`(QM=#%GPG7z>bF0ozs z&Z2Sq#=Tpg(rt#ode;uX-S{ggu7Zm?Ke=1Sf^AwQHQga~DLef+?CY%7aC&$XS-^wD zw&QA6J$NX+vrdZ>F?bDg%{q39Xy&j^+K8sIPod}XHd*nzFN%_YlwywG!6MOAYkPW$>IYg)0h7 zYfVBky1;r^B@q5Xm;A2Yi@W~Mw#-fPiw399_~oR4L0ZKzg3pUD#)g|}`t&ubG=Uv4 z+-1%xvH(n39ROELOpkAoU6I(#R0=8K?c5dM{eZgdn6i~|QhXqF0Q~)+m2DvZa}Zq) zhh7Eu$!w`V^ct1ob~4o>v*Uqf-;nW1O26v)3P%Gy$JS>ZN(e=5y87Vh&KEbDft;ub z=Og$`CO4mM!E_{zc5_hbcUD+YZiY)LNRsha>o<}lg>AlSCGr!oW8+ zU(2{Hwp-7@oP{{l7HBlV%o;tgnCiNukr%IK?}aUW-I_P#B&5eIMA6z*yB9P(rOXe< z{XVI+&iqk4LU~n%$=m?rzwBm|_V`MSUeIzhlP!B?%}fverxj|a=2A!R&YbVlUd!6` z`P^6ixjC-RUoSU*L!^528?G)}zO0gC*gE#JGdVtQ#_ai(!P9@~SIu!&EYLgR&KuOTkAIMaL%ZSCA@ z-)gqJLo{P72ZrLa`?6aT1A@W_U5$BhuDPG8Z3FjU(}!;yhs%~ybGpxt?%h8dd(J;Q+|c~( zXsr`SauHU|c4A{apZ27GhtDBe>(umVJ%Xx$KPq$fN~yU>v`^g>bQmunvSgv4W|R%A z<-;vx&kmk|JK6D5$}zP_{i$`N{3+}HwSh4aBNm<}*^i$~zIiV%c+zxf^=$;_84J@N zT8_Z%26a{KSe~FX#A7>?fXfne&jyM@x#2grsJ9EBaYJ$M4g1ZIB|ls9S6xUSl@!%q z;$COou&@(CQ$j*b4V5{LC=3RsgLI_Cv#FXW6`>PxLpvOY-HN)XY~ZIo zM_uiV=MHrUf%|wN`0R=bb7l_kZ>ulD!u=a#HQw4$P3}e^mE-P$ncE z7NCWw`4RB8==;ugiWSINy71}@V!Y{5kbxh{Z2{-*LKY3GuR;HO&N$+>&po&BYwq`m zDcco*sr>l?)arr{KXEh?#6ETjI7vY<6(ALTMT^QKuz2>}0Yzr^J`K}Y9on4Gbar0M z-KiCzs{cO(rZG0 zrr`8`Z~yKOb;s72bE=$`AG?1CxoaZ|#>brqQSr>~MR-b4VBJG{kx@ev4B zEt*hdk}Y`!-Oz1YkM#7t2>idc;l+l8{vCks)BjM>hy8a>4dgp-o^8o154peHi^dj4 JFAT7e{{b7QLec;L literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs.png b/en/chapter_graph/graph_traversal.assets/graph_dfs.png new file mode 100644 index 0000000000000000000000000000000000000000..47939ed0781bd35fd038705163e1d15f9729c0b7 GIT binary patch literal 25724 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 bUjTyr$JfKkE0;dM|BMx7)nqE9V4waEf!x?^ literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step1.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..5475e3c6129b9a7a0b8fe2ec546b2303fe6f1106 GIT binary patch literal 16659 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step10.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step10.png new file mode 100644 index 0000000000000000000000000000000000000000..c749a5f85db0697dd77d99f48b6852c0a9237ec8 GIT binary patch literal 29134 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step2.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step2.png new file mode 100644 index 0000000000000000000000000000000000000000..656d08c6c8ec8dd7c218894fffb68ca9bdf350d5 GIT binary patch literal 21010 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�e3*ph&7AI@;kp? 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 G#D4$+7yR)6 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step3.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..e69a50d3d8c80a84afabf2b03f70ad576d59a21f GIT binary patch literal 21987 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 IX`!C}59BqN3jhEB literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step4.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step4.png new file mode 100644 index 0000000000000000000000000000000000000000..a0ff56f92f41804fec081accfd111a63ba23cf9c GIT binary patch literal 22780 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 Qo97tNP}8|tq+<2-KUpxW+W-In literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step5.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step5.png new file mode 100644 index 0000000000000000000000000000000000000000..7c174e36677220c22b2c562206834f46ebe5792c GIT binary patch literal 23368 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 Vs?N!Ilm4GNEp@${@2}&Y{6Ae%8%O{E literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step6.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step6.png new file mode 100644 index 0000000000000000000000000000000000000000..23a01664a91df1774b64c7892169706b36ed0d41 GIT binary patch literal 25699 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⋁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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step8.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step8.png new file mode 100644 index 0000000000000000000000000000000000000000..b2d529514fe129a2f3017f87ffc30a14c248cc90 GIT binary patch literal 27335 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 ?kI(@g>5^*^SXpCpoDvdNbTV7i=L|Px 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 literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal.assets/graph_dfs_step9.png b/en/chapter_graph/graph_traversal.assets/graph_dfs_step9.png new file mode 100644 index 0000000000000000000000000000000000000000..1a114f14c0993f691e21ed581464cda1e554c396 GIT binary patch literal 32797 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 TuqGez?=KYv4f)y^<{|$N^>4Me literal 0 HcmV?d00001 diff --git a/en/chapter_graph/graph_traversal/index.html b/en/chapter_graph/graph_traversal/index.html new file mode 100644 index 000000000..24f19368c --- /dev/null +++ b/en/chapter_graph/graph_traversal/index.html @@ -0,0 +1,3324 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 9.3 Graph Traversal - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    9.3   Graph traversal

    +

    Trees represent a "one-to-many" relationship, while graphs have a higher degree of freedom and can represent any "many-to-many" relationship. Therefore, we can consider trees as a special case of graphs. Clearly, tree traversal operations are also a special case of graph traversal operations.

    +

    Both graphs and trees require the application of search algorithms to implement traversal operations. Graph traversal can be divided into two types: "Breadth-First Search (BFS)" and "Depth-First Search (DFS)".

    + +

    Breadth-first search is a near-to-far traversal method, starting from a certain node, always prioritizing the visit to the nearest vertices and expanding outwards layer by layer. As shown in the Figure 9-9 , starting from the top left vertex, first traverse all adjacent vertices of that vertex, then traverse all adjacent vertices of the next vertex, and so on, until all vertices have been visited.

    +

    Breadth-first traversal of a graph

    +

    Figure 9-9   Breadth-first traversal of a graph

    + +

    1.   Algorithm implementation

    +

    BFS is usually implemented with the help of a queue, as shown in the code below. The queue has a "first in, first out" property, which aligns with the BFS idea of traversing "from near to far".

    +
      +
    1. Add the starting vertex startVet to the queue and start the loop.
      2. +
    2. In each iteration of the loop, pop the vertex at the front of the queue and record it as visited, then add all adjacent vertices of that vertex to the back of the queue.
      3. +
    3. Repeat step 2. until all vertices have been visited.
      4. +
    +

    To prevent revisiting vertices, we use a hash table visited to record which nodes have been visited.

    +
    +
    +
    +
    graph_bfs.py
    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
+    """广度优先遍历"""
+    # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    # 顶点遍历序列
+    res = []
+    # 哈希表，用于记录已被访问过的顶点
+    visited = set[Vertex]([start_vet])
+    # 队列用于实现 BFS
+    que = deque[Vertex]([start_vet])
+    # 以顶点 vet 为起点，循环直至访问完所有顶点
+    while len(que) > 0:
+        vet = que.popleft()  # 队首顶点出队
+        res.append(vet)  # 记录访问顶点
+        # 遍历该顶点的所有邻接顶点
+        for adj_vet in graph.adj_list[vet]:
+            if adj_vet in visited:
+                continue  # 跳过已被访问的顶点
+            que.append(adj_vet)  # 只入队未访问的顶点
+            visited.add(adj_vet)  # 标记该顶点已被访问
+    # 返回顶点遍历序列
+    return res
+
    +
    +
    +
    graph_bfs.cpp
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+vector<Vertex *> graphBFS(GraphAdjList &graph, Vertex *startVet) {
+    // 顶点遍历序列
+    vector<Vertex *> res;
+    // 哈希表，用于记录已被访问过的顶点
+    unordered_set<Vertex *> visited = {startVet};
+    // 队列用于实现 BFS
+    queue<Vertex *> que;
+    que.push(startVet);
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while (!que.empty()) {
+        Vertex *vet = que.front();
+        que.pop();          // 队首顶点出队
+        res.push_back(vet); // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        for (auto adjVet : graph.adjList[vet]) {
+            if (visited.count(adjVet))
+                continue;            // 跳过已被访问的顶点
+            que.push(adjVet);        // 只入队未访问的顶点
+            visited.emplace(adjVet); // 标记该顶点已被访问
+        }
+    }
+    // 返回顶点遍历序列
+    return res;
+}
+
    +
    +
    +
    graph_bfs.java
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+    // 顶点遍历序列
+    List<Vertex> res = new ArrayList<>();
+    // 哈希表，用于记录已被访问过的顶点
+    Set<Vertex> visited = new HashSet<>();
+    visited.add(startVet);
+    // 队列用于实现 BFS
+    Queue<Vertex> que = new LinkedList<>();
+    que.offer(startVet);
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while (!que.isEmpty()) {
+        Vertex vet = que.poll(); // 队首顶点出队
+        res.add(vet);            // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        for (Vertex adjVet : graph.adjList.get(vet)) {
+            if (visited.contains(adjVet))
+                continue;        // 跳过已被访问的顶点
+            que.offer(adjVet);   // 只入队未访问的顶点
+            visited.add(adjVet); // 标记该顶点已被访问
+        }
+    }
+    // 返回顶点遍历序列
+    return res;
+}
+
    +
    +
    +
    graph_bfs.cs
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+List<Vertex> GraphBFS(GraphAdjList graph, Vertex startVet) {
+    // 顶点遍历序列
+    List<Vertex> res = [];
+    // 哈希表，用于记录已被访问过的顶点
+    HashSet<Vertex> visited = [startVet];
+    // 队列用于实现 BFS
+    Queue<Vertex> que = new();
+    que.Enqueue(startVet);
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while (que.Count > 0) {
+        Vertex vet = que.Dequeue(); // 队首顶点出队
+        res.Add(vet);               // 记录访问顶点
+        foreach (Vertex adjVet in graph.adjList[vet]) {
+            if (visited.Contains(adjVet)) {
+                continue;          // 跳过已被访问的顶点
+            }
+            que.Enqueue(adjVet);   // 只入队未访问的顶点
+            visited.Add(adjVet);   // 标记该顶点已被访问
+        }
+    }
+
+    // 返回顶点遍历序列
+    return res;
+}
+
    +
    +
    +
    graph_bfs.go
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+func graphBFS(g *graphAdjList, startVet Vertex) []Vertex {
+    // 顶点遍历序列
+    res := make([]Vertex, 0)
+    // 哈希表，用于记录已被访问过的顶点
+    visited := make(map[Vertex]struct{})
+    visited[startVet] = struct{}{}
+    // 队列用于实现 BFS, 使用切片模拟队列
+    queue := make([]Vertex, 0)
+    queue = append(queue, startVet)
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    for len(queue) > 0 {
+        // 队首顶点出队
+        vet := queue[0]
+        queue = queue[1:]
+        // 记录访问顶点
+        res = append(res, vet)
+        // 遍历该顶点的所有邻接顶点
+        for _, adjVet := range g.adjList[vet] {
+            _, isExist := visited[adjVet]
+            // 只入队未访问的顶点
+            if !isExist {
+                queue = append(queue, adjVet)
+                visited[adjVet] = struct{}{}
+            }
+        }
+    }
+    // 返回顶点遍历序列
+    return res
+}
+
    +
    +
    +
    graph_bfs.swift
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+func graphBFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {
+    // 顶点遍历序列
+    var res: [Vertex] = []
+    // 哈希表，用于记录已被访问过的顶点
+    var visited: Set<Vertex> = [startVet]
+    // 队列用于实现 BFS
+    var que: [Vertex] = [startVet]
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while !que.isEmpty {
+        let vet = que.removeFirst() // 队首顶点出队
+        res.append(vet) // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        for adjVet in graph.adjList[vet] ?? [] {
+            if visited.contains(adjVet) {
+                continue // 跳过已被访问的顶点
+            }
+            que.append(adjVet) // 只入队未访问的顶点
+            visited.insert(adjVet) // 标记该顶点已被访问
+        }
+    }
+    // 返回顶点遍历序列
+    return res
+}
+
    +
    +
    +
    graph_bfs.js
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+function graphBFS(graph, startVet) {
+    // 顶点遍历序列
+    const res = [];
+    // 哈希表，用于记录已被访问过的顶点
+    const visited = new Set();
+    visited.add(startVet);
+    // 队列用于实现 BFS
+    const que = [startVet];
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while (que.length) {
+        const vet = que.shift(); // 队首顶点出队
+        res.push(vet); // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        for (const adjVet of graph.adjList.get(vet) ?? []) {
+            if (visited.has(adjVet)) {
+                continue; // 跳过已被访问的顶点
+            }
+            que.push(adjVet); // 只入队未访问的顶点
+            visited.add(adjVet); // 标记该顶点已被访问
+        }
+    }
+    // 返回顶点遍历序列
+    return res;
+}
+
    +
    +
    +
    graph_bfs.ts
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+function graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
+    // 顶点遍历序列
+    const res: Vertex[] = [];
+    // 哈希表，用于记录已被访问过的顶点
+    const visited: Set<Vertex> = new Set();
+    visited.add(startVet);
+    // 队列用于实现 BFS
+    const que = [startVet];
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while (que.length) {
+        const vet = que.shift(); // 队首顶点出队
+        res.push(vet); // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        for (const adjVet of graph.adjList.get(vet) ?? []) {
+            if (visited.has(adjVet)) {
+                continue; // 跳过已被访问的顶点
+            }
+            que.push(adjVet); // 只入队未访问
+            visited.add(adjVet); // 标记该顶点已被访问
+        }
+    }
+    // 返回顶点遍历序列
+    return res;
+}
+
    +
    +
    +
    graph_bfs.dart
    /* 广度优先遍历 */
+List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+  // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+  // 顶点遍历序列
+  List<Vertex> res = [];
+  // 哈希表，用于记录已被访问过的顶点
+  Set<Vertex> visited = {};
+  visited.add(startVet);
+  // 队列用于实现 BFS
+  Queue<Vertex> que = Queue();
+  que.add(startVet);
+  // 以顶点 vet 为起点，循环直至访问完所有顶点
+  while (que.isNotEmpty) {
+    Vertex vet = que.removeFirst(); // 队首顶点出队
+    res.add(vet); // 记录访问顶点
+    // 遍历该顶点的所有邻接顶点
+    for (Vertex adjVet in graph.adjList[vet]!) {
+      if (visited.contains(adjVet)) {
+        continue; // 跳过已被访问的顶点
+      }
+      que.add(adjVet); // 只入队未访问的顶点
+      visited.add(adjVet); // 标记该顶点已被访问
+    }
+  }
+  // 返回顶点遍历序列
+  return res;
+}
+
    +
    +
    +
    graph_bfs.rs
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+fn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
+    // 顶点遍历序列
+    let mut res = vec![];
+    // 哈希表，用于记录已被访问过的顶点
+    let mut visited = HashSet::new();
+    visited.insert(start_vet);
+    // 队列用于实现 BFS
+    let mut que = VecDeque::new();
+    que.push_back(start_vet);
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while !que.is_empty() {
+        let vet = que.pop_front().unwrap(); // 队首顶点出队
+        res.push(vet); // 记录访问顶点
+
+        // 遍历该顶点的所有邻接顶点
+        if let Some(adj_vets) = graph.adj_list.get(&vet) {
+            for &adj_vet in adj_vets {
+                if visited.contains(&adj_vet) {
+                    continue; // 跳过已被访问的顶点
+                }
+                que.push_back(adj_vet); // 只入队未访问的顶点
+                visited.insert(adj_vet); // 标记该顶点已被访问
+            }
+        }
+    }
+    // 返回顶点遍历序列
+    res
+}
+
    +
    +
    +
    graph_bfs.c
    /* 节点队列结构体 */
+typedef struct {
+    Vertex *vertices[MAX_SIZE];
+    int front, rear, size;
+} Queue;
+
+/* 构造函数 */
+Queue *newQueue() {
+    Queue *q = (Queue *)malloc(sizeof(Queue));
+    q->front = q->rear = q->size = 0;
+    return q;
+}
+
+/* 判断队列是否为空 */
+int isEmpty(Queue *q) {
+    return q->size == 0;
+}
+
+/* 入队操作 */
+void enqueue(Queue *q, Vertex *vet) {
+    q->vertices[q->rear] = vet;
+    q->rear = (q->rear + 1) % MAX_SIZE;
+    q->size++;
+}
+
+/* 出队操作 */
+Vertex *dequeue(Queue *q) {
+    Vertex *vet = q->vertices[q->front];
+    q->front = (q->front + 1) % MAX_SIZE;
+    q->size--;
+    return vet;
+}
+
+/* 检查顶点是否已被访问 */
+int isVisited(Vertex **visited, int size, Vertex *vet) {
+    // 遍历查找节点，使用 O(n) 时间
+    for (int i = 0; i < size; i++) {
+        if (visited[i] == vet)
+            return 1;
+    }
+    return 0;
+}
+
+/* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+void graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {
+    // 队列用于实现 BFS
+    Queue *queue = newQueue();
+    enqueue(queue, startVet);
+    visited[(*visitedSize)++] = startVet;
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while (!isEmpty(queue)) {
+        Vertex *vet = dequeue(queue); // 队首顶点出队
+        res[(*resSize)++] = vet;      // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        AdjListNode *node = findNode(graph, vet);
+        while (node != NULL) {
+            // 跳过已被访问的顶点
+            if (!isVisited(visited, *visitedSize, node->vertex)) {
+                enqueue(queue, node->vertex);             // 只入队未访问的顶点
+                visited[(*visitedSize)++] = node->vertex; // 标记该顶点已被访问
+            }
+            node = node->next;
+        }
+    }
+    // 释放内存
+    free(queue);
+}
+
    +
    +
    +
    graph_bfs.kt
    /* 广度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+fun graphBFS(graph: GraphAdjList, startVet: Vertex): List<Vertex> {
+    // 顶点遍历序列
+    val res: MutableList<Vertex> = ArrayList()
+    // 哈希表，用于记录已被访问过的顶点
+    val visited: MutableSet<Vertex> = HashSet()
+    visited.add(startVet)
+    // 队列用于实现 BFS
+    val que: Queue<Vertex> = LinkedList()
+    que.offer(startVet)
+    // 以顶点 vet 为起点，循环直至访问完所有顶点
+    while (!que.isEmpty()) {
+        val vet = que.poll() // 队首顶点出队
+        res.add(vet) // 记录访问顶点
+        // 遍历该顶点的所有邻接顶点
+        for (adjVet in graph.adjList[vet]!!) {
+            if (visited.contains(adjVet)) continue  // 跳过已被访问的顶点
+
+            que.offer(adjVet) // 只入队未访问的顶点
+            visited.add(adjVet) // 标记该顶点已被访问
+        }
+    }
+    // 返回顶点遍历序列
+    return res
+}
+
    +
    +
    +
    graph_bfs.rb
    [class]{}-[func]{graph_bfs}
+
    +
    +
    +
    graph_bfs.zig
    [class]{}-[func]{graphBFS}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    The code is relatively abstract, it is suggested to compare with the following figure to deepen the understanding.

    +
    +
    +
    +

    Steps of breadth-first search of a graph

    +
    +
    +

    graph_bfs_step2

    +
    +
    +

    graph_bfs_step3

    +
    +
    +

    graph_bfs_step4

    +
    +
    +

    graph_bfs_step5

    +
    +
    +

    graph_bfs_step6

    +
    +
    +

    graph_bfs_step7

    +
    +
    +

    graph_bfs_step8

    +
    +
    +

    graph_bfs_step9

    +
    +
    +

    graph_bfs_step10

    +
    +
    +

    graph_bfs_step11

    +
    +
    +
    +

    Figure 9-10   Steps of breadth-first search of a graph

    + +
    +

    Is the sequence of breadth-first traversal unique?

    +

    Not unique. Breadth-first traversal only requires traversing in a "from near to far" order, and the traversal order of multiple vertices at the same distance can be arbitrarily shuffled. For example, in the above figure, the visitation order of vertices \(1\) and \(3\) can be switched, as can the order of vertices \(2\), \(4\), and \(6\).

    +
    +

    2.   Complexity analysis

    +

    Time complexity: All vertices will be enqueued and dequeued once, using \(O(|V|)\) time; in the process of traversing adjacent vertices, since it is an undirected graph, all edges will be visited \(2\) times, using \(O(2|E|)\) time; overall using \(O(|V| + |E|)\) time.

    +

    Space complexity: The maximum number of vertices in list res, hash table visited, and queue que is \(|V|\), using \(O(|V|)\) space.

    + +

    Depth-first search is a traversal method that prioritizes going as far as possible and then backtracks when no further paths are available. As shown in the Figure 9-11 , starting from the top left vertex, visit some adjacent vertex of the current vertex until no further path is available, then return and continue until all vertices are traversed.

    +

    Depth-first traversal of a graph

    +

    Figure 9-11   Depth-first traversal of a graph

    + +

    1.   Algorithm implementation

    +

    This "go as far as possible and then return" algorithm paradigm is usually implemented based on recursion. Similar to breadth-first search, in depth-first search, we also need the help of a hash table visited to record the visited vertices to avoid revisiting.

    +
    +
    +
    +
    graph_dfs.py
    def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):
+    """深度优先遍历辅助函数"""
+    res.append(vet)  # 记录访问顶点
+    visited.add(vet)  # 标记该顶点已被访问
+    # 遍历该顶点的所有邻接顶点
+    for adjVet in graph.adj_list[vet]:
+        if adjVet in visited:
+            continue  # 跳过已被访问的顶点
+        # 递归访问邻接顶点
+        dfs(graph, visited, res, adjVet)
+
+def graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:
+    """深度优先遍历"""
+    # 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+    # 顶点遍历序列
+    res = []
+    # 哈希表，用于记录已被访问过的顶点
+    visited = set[Vertex]()
+    dfs(graph, visited, res, start_vet)
+    return res
+
    +
    +
    +
    graph_dfs.cpp
    /* 深度优先遍历辅助函数 */
+void dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {
+    res.push_back(vet);   // 记录访问顶点
+    visited.emplace(vet); // 标记该顶点已被访问
+    // 遍历该顶点的所有邻接顶点
+    for (Vertex *adjVet : graph.adjList[vet]) {
+        if (visited.count(adjVet))
+            continue; // 跳过已被访问的顶点
+        // 递归访问邻接顶点
+        dfs(graph, visited, res, adjVet);
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+vector<Vertex *> graphDFS(GraphAdjList &graph, Vertex *startVet) {
+    // 顶点遍历序列
+    vector<Vertex *> res;
+    // 哈希表，用于记录已被访问过的顶点
+    unordered_set<Vertex *> visited;
+    dfs(graph, visited, res, startVet);
+    return res;
+}
+
    +
    +
    +
    graph_dfs.java
    /* 深度优先遍历辅助函数 */
+void dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {
+    res.add(vet);     // 记录访问顶点
+    visited.add(vet); // 标记该顶点已被访问
+    // 遍历该顶点的所有邻接顶点
+    for (Vertex adjVet : graph.adjList.get(vet)) {
+        if (visited.contains(adjVet))
+            continue; // 跳过已被访问的顶点
+        // 递归访问邻接顶点
+        dfs(graph, visited, res, adjVet);
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
+    // 顶点遍历序列
+    List<Vertex> res = new ArrayList<>();
+    // 哈希表，用于记录已被访问过的顶点
+    Set<Vertex> visited = new HashSet<>();
+    dfs(graph, visited, res, startVet);
+    return res;
+}
+
    +
    +
    +
    graph_dfs.cs
    /* 深度优先遍历辅助函数 */
+void DFS(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {
+    res.Add(vet);     // 记录访问顶点
+    visited.Add(vet); // 标记该顶点已被访问
+    // 遍历该顶点的所有邻接顶点
+    foreach (Vertex adjVet in graph.adjList[vet]) {
+        if (visited.Contains(adjVet)) {
+            continue; // 跳过已被访问的顶点                             
+        }
+        // 递归访问邻接顶点
+        DFS(graph, visited, res, adjVet);
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+List<Vertex> GraphDFS(GraphAdjList graph, Vertex startVet) {
+    // 顶点遍历序列
+    List<Vertex> res = [];
+    // 哈希表，用于记录已被访问过的顶点
+    HashSet<Vertex> visited = [];
+    DFS(graph, visited, res, startVet);
+    return res;
+}
+
    +
    +
    +
    graph_dfs.go
    /* 深度优先遍历辅助函数 */
+func dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {
+    // append 操作会返回新的的引用，必须让原引用重新赋值为新slice的引用
+    *res = append(*res, vet)
+    visited[vet] = struct{}{}
+    // 遍历该顶点的所有邻接顶点
+    for _, adjVet := range g.adjList[vet] {
+        _, isExist := visited[adjVet]
+        // 递归访问邻接顶点
+        if !isExist {
+            dfs(g, visited, res, adjVet)
+        }
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+func graphDFS(g *graphAdjList, startVet Vertex) []Vertex {
+    // 顶点遍历序列
+    res := make([]Vertex, 0)
+    // 哈希表，用于记录已被访问过的顶点
+    visited := make(map[Vertex]struct{})
+    dfs(g, visited, &res, startVet)
+    // 返回顶点遍历序列
+    return res
+}
+
    +
    +
    +
    graph_dfs.swift
    /* 深度优先遍历辅助函数 */
+func dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {
+    res.append(vet) // 记录访问顶点
+    visited.insert(vet) // 标记该顶点已被访问
+    // 遍历该顶点的所有邻接顶点
+    for adjVet in graph.adjList[vet] ?? [] {
+        if visited.contains(adjVet) {
+            continue // 跳过已被访问的顶点
+        }
+        // 递归访问邻接顶点
+        dfs(graph: graph, visited: &visited, res: &res, vet: adjVet)
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+func graphDFS(graph: GraphAdjList, startVet: Vertex) -> [Vertex] {
+    // 顶点遍历序列
+    var res: [Vertex] = []
+    // 哈希表，用于记录已被访问过的顶点
+    var visited: Set<Vertex> = []
+    dfs(graph: graph, visited: &visited, res: &res, vet: startVet)
+    return res
+}
+
    +
    +
    +
    graph_dfs.js
    /* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+function dfs(graph, visited, res, vet) {
+    res.push(vet); // 记录访问顶点
+    visited.add(vet); // 标记该顶点已被访问
+    // 遍历该顶点的所有邻接顶点
+    for (const adjVet of graph.adjList.get(vet)) {
+        if (visited.has(adjVet)) {
+            continue; // 跳过已被访问的顶点
+        }
+        // 递归访问邻接顶点
+        dfs(graph, visited, res, adjVet);
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+function graphDFS(graph, startVet) {
+    // 顶点遍历序列
+    const res = [];
+    // 哈希表，用于记录已被访问过的顶点
+    const visited = new Set();
+    dfs(graph, visited, res, startVet);
+    return res;
+}
+
    +
    +
    +
    graph_dfs.ts
    /* 深度优先遍历辅助函数 */
+function dfs(
+    graph: GraphAdjList,
+    visited: Set<Vertex>,
+    res: Vertex[],
+    vet: Vertex
+): void {
+    res.push(vet); // 记录访问顶点
+    visited.add(vet); // 标记该顶点已被访问
+    // 遍历该顶点的所有邻接顶点
+    for (const adjVet of graph.adjList.get(vet)) {
+        if (visited.has(adjVet)) {
+            continue; // 跳过已被访问的顶点
+        }
+        // 递归访问邻接顶点
+        dfs(graph, visited, res, adjVet);
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+function graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
+    // 顶点遍历序列
+    const res: Vertex[] = [];
+    // 哈希表，用于记录已被访问过的顶点
+    const visited: Set<Vertex> = new Set();
+    dfs(graph, visited, res, startVet);
+    return res;
+}
+
    +
    +
    +
    graph_dfs.dart
    /* 深度优先遍历辅助函数 */
+void dfs(
+  GraphAdjList graph,
+  Set<Vertex> visited,
+  List<Vertex> res,
+  Vertex vet,
+) {
+  res.add(vet); // 记录访问顶点
+  visited.add(vet); // 标记该顶点已被访问
+  // 遍历该顶点的所有邻接顶点
+  for (Vertex adjVet in graph.adjList[vet]!) {
+    if (visited.contains(adjVet)) {
+      continue; // 跳过已被访问的顶点
+    }
+    // 递归访问邻接顶点
+    dfs(graph, visited, res, adjVet);
+  }
+}
+
+/* 深度优先遍历 */
+List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
+  // 顶点遍历序列
+  List<Vertex> res = [];
+  // 哈希表，用于记录已被访问过的顶点
+  Set<Vertex> visited = {};
+  dfs(graph, visited, res, startVet);
+  return res;
+}
+
    +
    +
    +
    graph_dfs.rs
    /* 深度优先遍历辅助函数 */
+fn dfs(graph: &GraphAdjList, visited: &mut HashSet<Vertex>, res: &mut Vec<Vertex>, vet: Vertex) {
+    res.push(vet); // 记录访问顶点
+    visited.insert(vet); // 标记该顶点已被访问
+                         // 遍历该顶点的所有邻接顶点
+    if let Some(adj_vets) = graph.adj_list.get(&vet) {
+        for &adj_vet in adj_vets {
+            if visited.contains(&adj_vet) {
+                continue; // 跳过已被访问的顶点
+            }
+            // 递归访问邻接顶点
+            dfs(graph, visited, res, adj_vet);
+        }
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+fn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {
+    // 顶点遍历序列
+    let mut res = vec![];
+    // 哈希表，用于记录已被访问过的顶点
+    let mut visited = HashSet::new();
+    dfs(&graph, &mut visited, &mut res, start_vet);
+
+    res
+}
+
    +
    +
    +
    graph_dfs.c
    /* 检查顶点是否已被访问 */
+int isVisited(Vertex **res, int size, Vertex *vet) {
+    // 遍历查找节点，使用 O(n) 时间
+    for (int i = 0; i < size; i++) {
+        if (res[i] == vet) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+/* 深度优先遍历辅助函数 */
+void dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {
+    // 记录访问顶点
+    res[(*resSize)++] = vet;
+    // 遍历该顶点的所有邻接顶点
+    AdjListNode *node = findNode(graph, vet);
+    while (node != NULL) {
+        // 跳过已被访问的顶点
+        if (!isVisited(res, *resSize, node->vertex)) {
+            // 递归访问邻接顶点
+            dfs(graph, res, resSize, node->vertex);
+        }
+        node = node->next;
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+void graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {
+    dfs(graph, res, resSize, startVet);
+}
+
    +
    +
    +
    graph_dfs.kt
    /* 深度优先遍历辅助函数 */
+fun dfs(
+    graph: GraphAdjList,
+    visited: MutableSet<Vertex?>,
+    res: MutableList<Vertex?>,
+    vet: Vertex?
+) {
+    res.add(vet) // 记录访问顶点
+    visited.add(vet) // 标记该顶点已被访问
+    // 遍历该顶点的所有邻接顶点
+    for (adjVet in graph.adjList[vet]!!) {
+        if (visited.contains(adjVet)) continue  // 跳过已被访问的顶点
+        // 递归访问邻接顶点
+        dfs(graph, visited, res, adjVet)
+    }
+}
+
+/* 深度优先遍历 */
+// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
+fun graphDFS(
+    graph: GraphAdjList,
+    startVet: Vertex?
+): List<Vertex?> {
+    // 顶点遍历序列
+    val res: MutableList<Vertex?> = ArrayList()
+    // 哈希表，用于记录已被访问过的顶点
+    val visited: MutableSet<Vertex?> = HashSet()
+    dfs(graph, visited, res, startVet)
+    return res
+}
+
    +
    +
    +
    graph_dfs.rb
    [class]{}-[func]{dfs}
+
+[class]{}-[func]{graph_dfs}
+
    +
    +
    +
    graph_dfs.zig
    [class]{}-[func]{dfs}
+
+[class]{}-[func]{graphDFS}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    The algorithm process of depth-first search is shown in the following figure.

    +
      +
    • Dashed lines represent downward recursion, indicating that a new recursive method has been initiated to visit a new vertex.
      • +
    • Curved dashed lines represent upward backtracking, indicating that this recursive method has returned to the position where this method was initiated.
      • +
    +

    To deepen the understanding, it is suggested to combine the following figure with the code to simulate (or draw) the entire DFS process in your mind, including when each recursive method is initiated and when it returns.

    +
    +
    +
    +

    Steps of depth-first search of a graph

    +
    +
    +

    graph_dfs_step2

    +
    +
    +

    graph_dfs_step3

    +
    +
    +

    graph_dfs_step4

    +
    +
    +

    graph_dfs_step5

    +
    +
    +

    graph_dfs_step6

    +
    +
    +

    graph_dfs_step7

    +
    +
    +

    graph_dfs_step8

    +
    +
    +

    graph_dfs_step9

    +
    +
    +

    graph_dfs_step10

    +
    +
    +

    graph_dfs_step11

    +
    +
    +
    +

    Figure 9-12   Steps of depth-first search of a graph

    + +
    +

    Is the sequence of depth-first traversal unique?

    +

    Similar to breadth-first traversal, the order of the depth-first traversal sequence is also not unique. Given a certain vertex, exploring in any direction first is possible, that is, the order of adjacent vertices can be arbitrarily shuffled, all being part of depth-first traversal.

    +

    Taking tree traversal as an example, "root \(\rightarrow\) left \(\rightarrow\) right", "left \(\rightarrow\) root \(\rightarrow\) right", "left \(\rightarrow\) right \(\rightarrow\) root" correspond to preorder, inorder, and postorder traversals, respectively. They showcase three types of traversal priorities, yet all three are considered depth-first traversal.

    +
    +

    2.   Complexity analysis

    +

    Time complexity: All vertices will be visited once, using \(O(|V|)\) time; all edges will be visited twice, using \(O(2|E|)\) time; overall using \(O(|V| + |E|)\) time.

    +

    Space complexity: The maximum number of vertices in list res, hash table visited is \(|V|\), and the maximum recursion depth is \(|V|\), therefore using \(O(|V|)\) space.

    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_graph/index.html b/en/chapter_graph/index.html new file mode 100644 index 000000000..54a64609d --- /dev/null +++ b/en/chapter_graph/index.html @@ -0,0 +1,2273 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Chapter 9.   Graph - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    Chapter 9.   Graph

    +

    Graph

    +
    +

    Abstract

    +

    In the journey of life, we are like individual nodes, connected by countless invisible edges.

    +

    Every encountering and parting leaves a unique mark on this vast network graph.

    +
    +

    Chapter Contents

    + + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_graph/summary/index.html b/en/chapter_graph/summary/index.html new file mode 100644 index 000000000..c1b1ec2dd --- /dev/null +++ b/en/chapter_graph/summary/index.html @@ -0,0 +1,2310 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + 9.4 Summary - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    9.4   Summary

    +

    1.   Key review

    +
      +
    • A graph consists of vertices and edges and can be represented as a set comprising a group of vertices and a group of edges.
      • +
    • Compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) have a higher degree of freedom and are therefore more complex.
      • +
    • The edges of a directed graph have directionality, any vertex in a connected graph is reachable, and each edge in a weighted graph contains a weight variable.
      • +
    • Adjacency matrices use matrices to represent graphs, with each row (column) representing a vertex and matrix elements representing edges, using \(1\) or \(0\) to indicate the presence or absence of an edge between two vertices. Adjacency matrices are highly efficient for add, delete, find, and modify operations, but they consume more space.
      • +
    • Adjacency lists use multiple linked lists to represent graphs, with the \(i^{th}\) list corresponding to vertex \(i\), containing all its adjacent vertices. Adjacency lists save more space compared to adjacency matrices, but since it is necessary to traverse the list to find edges, their time efficiency is lower.
      • +
    • When the linked lists in the adjacency list are too long, they can be converted into red-black trees or hash tables to improve query efficiency.
      • +
    • From the perspective of algorithmic thinking, adjacency matrices embody the principle of "space for time," while adjacency lists embody "time for space."
      • +
    • Graphs can be used to model various real systems, such as social networks, subway routes, etc.
      • +
    • A tree is a special case of a graph, and tree traversal is also a special case of graph traversal.
      • +
    • Breadth-first traversal of a graph is a search method that expands layer by layer from near to far, usually implemented with a queue.
      • +
    • Depth-first traversal of a graph is a search method that prefers to go as deep as possible and backtracks when no further paths are available, often based on recursion.
      • +
    +

    2.   Q & A

    +

    Q: Is a path defined as a sequence of vertices or a sequence of edges?

    +

    Definitions vary between different language versions on Wikipedia: the English version defines a path as "a sequence of edges," while the Chinese version defines it as "a sequence of vertices." Here is the original text from the English version: In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.

    +

    In this document, a path is considered a sequence of edges, rather than a sequence of vertices. This is because there might be multiple edges connecting two vertices, in which case each edge corresponds to a path.

    +

    Q: In a disconnected graph, are there points that cannot be traversed to?

    +

    In a disconnected graph, starting from a certain vertex, there is at least one vertex that cannot be reached. Traversing a disconnected graph requires setting multiple starting points to traverse all connected components of the graph.

    +

    Q: In an adjacency list, does the order of "all vertices connected to that vertex" matter?

    +

    It can be in any order. However, in practical applications, it might be necessary to sort according to certain rules, such as the order in which vertices are added, or the order of vertex values, etc., to facilitate the quick search for vertices with certain extremal values.

    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_hashing/hash_algorithm/index.html b/en/chapter_hashing/hash_algorithm/index.html index 4fe38dc70..d1b7308e5 100644 --- a/en/chapter_hashing/hash_algorithm/index.html +++ b/en/chapter_hashing/hash_algorithm/index.html @@ -1491,6 +1491,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_hashing/hash_collision/index.html b/en/chapter_hashing/hash_collision/index.html index 765775047..381b68077 100644 --- a/en/chapter_hashing/hash_collision/index.html +++ b/en/chapter_hashing/hash_collision/index.html @@ -1524,6 +1524,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_hashing/hash_map/index.html b/en/chapter_hashing/hash_map/index.html index 24b11870e..6c11f4747 100644 --- a/en/chapter_hashing/hash_map/index.html +++ b/en/chapter_hashing/hash_map/index.html @@ -1491,6 +1491,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_hashing/index.html b/en/chapter_hashing/index.html index 521fb8bac..fc51ce577 100644 --- a/en/chapter_hashing/index.html +++ b/en/chapter_hashing/index.html @@ -1424,6 +1424,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_hashing/summary/index.html b/en/chapter_hashing/summary/index.html index 94aaf297f..9587c8e20 100644 --- a/en/chapter_hashing/summary/index.html +++ b/en/chapter_hashing/summary/index.html @@ -18,6 +18,8 @@ + + @@ -1480,6 +1482,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + @@ -1634,6 +2144,27 @@ aria-label="Footer" + + + @@ -1734,6 +2265,22 @@ aria-label="Footer" + + +
    + + Next + +
    + Chapter 7.   Tree +
    +
    +
    + + +
    +     + diff --git a/en/chapter_heap/build_heap.assets/heapify_operations_count.png b/en/chapter_heap/build_heap.assets/heapify_operations_count.png new file mode 100644 index 0000000000000000000000000000000000000000..644da4b930304b67de9c87eeb8bbaf88e6fd7844 GIT binary patch literal 16135 zcmaib1yEeww&v+>+?_^(6C?ylNN|_n8rOS#l@ADmd3=y)Ya8( zY;5f9?M+TjuB@yS6%|EBMjjs@D=RDi`0=B!udltm{pZi0jg5^72?^rj;){!m($dm- zd3h}@EtQp(QBhIq>gtx3mY+X=*7~9u5fM>cU43zJ(c0Q7C@5H7UVeFX8Bpy%HZ}%> z!9+wvzI^#&Yim2SI`rw&r@6Vgw6ru+Q&R&211&AB@$qq8U0oL!mz=(@K0ZE7 z|CX1Rw=c5mn*SD@^U1@*Bjj_4TgAtQ$@;LSP~)#gMZ-mL?XfdkGx@do8fofNpSvgl zKp;t4T;#p`!rnLkr& zu&_>65a9&BX&SY11*_vqMW$iUJ%$C~HXq&k#nlUIy$}y1F;6*_9RPVwI-lmT$rL{t z%%mg+*_xchZxnQyOfD(*>ZRs8I$3XE-Yvw&W!xqEwg0lv2sf9-x)h(8$d6>qU#Y}w zidDiClu>!k|F)Yj_A|*Cj8>~|m8;I_)l}h$<>0uv_0al@k9GHBq*qRp*1n7WI;l-( z@iIAy+WNb<{w7Ux*dC6g3S79z6DG(spZ2Sf#v^^pBBWaQjbS%ex4|son<91syx+V? ziaGN69-}9M6xWcm#;j2(%zi?d_45#u|9VOuIiV#987P*@)Otnp%1~RI$ehv=!MPj~ z*lq#levGbxxUJ0=kq zr(HVzC?nHZg1c3F2T$8`Q`ljrhjVL{qeLdHzkrJgT*arLeC(^TILUd=B&5QU8wio1 z-Y_z0_gp~X_gJgRE7+y@$8$8LVmB+i5Pg0ujZGzdM(lYur182%0chRgKI!{_xVT=& z>|ZShZie(JG2am#AD%6L){Rjz^Xdie1;;Cf#2URCKD$ip6Nxj`m#M!TcB-8(BV;zM zU1hOR3--w z^ghQA?4sv};(j`@41fKm+gr!{=3p@*X zX#~8xcl|{LBV?}(vFTf>7vEe`DuCe*4C!J>Rd4=dq8my;p8X6-$&SwtiRjBX?~^Ib z9s%6COK)&U4+m~jwP;)Aj8_g-n&W+zaQ_Hwjq#^s)We(c;!rW79}&h;CFK-@XW=tb{>b_ zyfzj4bam+9^^AYu0^QuWLJa(x)jzHnC@>Byu<~LH4Gh71zeeutq#lk61u1AEs6^Kpd|o9Bz3gYOqY&r$uTW->VrVzz~9#Mev8wo2ImlhpzRcqfE0*ZIk4Cas4i9 z>#DPy%>MI{1|MF@*eePT20_px@ISt5L)O+-*!ev)(FfMfG<@9}=sD(zxbGtgSzchr%*KUUL==l4*NsZ>RC zttZXq@s-#^HTG&J=jJD?7`f}R_s_AhSp`R~KJrt{_Bg&%sUv0Ob!AF9j}+UHy)KmU z(X63YE5%~@!71_NyTCHO9#r7R2}(D9K5)R(`9_G6@{p*gDO0cli?B>9XlI5r zeK%6>`E_!P}TV8}k!Q{EH4UtRwRu4ff!WswGxNCBZHFU=&5KPtg z%N(Xxib71d!!Q930V$${eAoWo%-98%|gh&QU`=Esdv-p5#LjNdcbo#8`uZ@9W8*N-)<|oQbI9 zftCHv-)ukIOlwBGrvM5+z(SGiqzI66?@vl}-LMW9zkIi`&4F%s+8rn&{*wiDk?Rt6 z-oJUG#cHt5r*F;4lk@%^Ar*#y25t2XYD3ObpPGWc-l+li@_;RHUW#rb?V`{Nyk&+L zv&ht+7oBN<(xZ%htTHuz*X7a{{|N5U*p(7-_xgxN)*T=m2_y|7*$uo`5OzRNRZYY> zyHv1#dUjx2T%U8my-|L~AGLun_}K`q3!uVgnFkr|uOB4lW>{eE|8a0RMptdYGS- z@hG1x$1W2erh$N&Ifz^+Uwm!D&gNY12Zq)y%|K^i&lqyjV;I)l5eoX#>AA%4I+oINck}?Wfoz1S zbcISCBx|Sbid!*W8l$IQ2RiZ}{`_dZ9sJGmGZsbrh`yL7=x-6}5Vk21mCPOgTz+@l zxxA%Ox!oxOE|`0A8kRJbm_E}ms=dCgVInbsy^7a;W=UG@3FvxBjwJeyKit1Xvg&1MV|tzPG4r#!!sg+}ERv zVFJB8SHF=^Ms^wvSGWQMWpouK7V%w_XI0W56o^oEGq$d=vy_5bq zj_A30dS9!p`mrO8=ls+Mz+C>ES zc>Qqd_0;$sg|};pOM5El`s-C+o25NVpDLV(T6O^1lRUCZfk)3t`f@6@?PH*HJA`%} z#UfXczv)Y6ff-aWbs$pA(sJM8kmRIz8S>)Sf;r850bYo)PMkgjWt1P*i_LO~^vmVk zsHO&I4v1zn$)4yafUG_Uf99`O;h1{bz8V7S>14(=)sSH(&$)UoXf%vJ*9?@o)3{K; zwI&BDkxcxPS1>Cy3|Vv%!}2an+tUz*Ia`n&-ylRc^qAvbDS|j@EunZKjXpyKWENDG z>L+fK3b0p};df1V=r=iKMhs6q&DK#9SGN8E-_<{Cwj>b)7nzlkSq^4aKM~W#;{i;H z*eZ9zcTt{%@xww8V6S9Iorj|QPYeBa4)3GHzO+*gS+2)mr}7w zL{e9?kz@d~O4NF>N0?!?MRn%ZKGq_Cw>U}KXY86wJ|Hvc`#B4}H05z-q$7;0+j|D3 zcmX#xE~*dnX%qDYJzZs%SYf;3TMVy4;`ti;oeS$I)b9#`lCfg%kKi0n_0e;?RTT zqG;xWVgxB6DUVUj1GW~!JbD9C-~;^Ix2$wIXz%clC(Ce3i>E&R?eq*tx;hQTtb~F1 zSnKEOQh?Q=Bm8OMO@nC^>iAgnyrzK{fJ4nWta{1~huewk8maPybCtxOig!OKzk?Fr zRQpqh3m~$*&MHHoo$i^Li#_fEj|C6Ju%mAMK|ub&xvzL}P(dHgh_!Y^@|`5+Yb|fy zPvf8AuDOJ1(nk4s^pZaQ9goCT=A2GWTqshZ9qf^Bmh?4mCpPvp zPD&<^K}(ndvU&hnGBO)0DZ{PWA=~p?%GsIHx2`dgqxHT#CAZy|KNa}&I{8pCzTIqn zTOSPR-s~+Oy}!{1N((E$uLxq7+drLC@9K_AejooC>z&vi>(6qSDcMXg-`4)31v~ze z%Y0Tob1riw{|2fX+|g1|8m49E@I$Bk;UcVk+Hp>HcDb=mS-xZ5F#qyK`PqLSW&U3j z>^jbwdANpg=v6)e@IcJ-Swb<@2}tp4ZnM)LTb5?e&sir&8EIb{ZRc4c@pqPz2KzV9 zerDY$@NvsuddWz|-s$9#(D^fSs=gY7{h4A?mfbYS{GB~svY1xnJPjDL9( z7^=IxYtxlW6jKo{FsAM+UFPCormD>;)nR?0s`t913P$D&KjsYjW5Z8@l!AEu))8$$ zs1ZL#Lv)TW=9nGM!svDXg&*7PIlI=@S=MthhY#t)19lLtMbOdJX{CGd4F25ug>J1(_u{&` z;kq5P-`*LL8%+yQj?Je&Qx-}vvq#x`L2QKDN8hf}zKH~%M_k6s_6=l#XBweabh}Cq zVoy_U0$2J6r3$D@Tta|3q&ogJIC^H~!1uIL{6LxG+DX4fzi4dGt^F6+T@2RZ%Fyb+ zVN3#gw`)>6fA?J3#&zoV68?6>pI_>&v^ClLb>=$agCCKFCE@J7l{L2YEN*GHz-XO8}!m9j)+ki-}$z7J0!H zgt5{-^ih>^bIcZe>xD&U{yoV>vaPX1C!>K? zfGFF(nd}dWVU;)F#Q_Uq;$Xt37Av@6m01Mwf2E&7tj-i&WF+ZfoFX+D+{;^LuD5w{3Yo9?&E}k;-ZbiSK$F<5KvEEybvCWq4)cf zcVJLt%;{DTNq#^rxtq0jSM(N$7klIBLjqNmmSE$V34hI#$TXc zZttG(S0)Tlq9PozrQRJIQ^DR8|K+i5{B=D-_m3A5e&!h01^{dSIN-$H0%I+dVtXYS z0ZjEbkjsM<6|nx-r0e=u@854)e<0{D5|r(j5Px7wb^W{rxT~zNySFg*vC9~?L8#J6 zRyjOdaeM9m>&Lz;cy79L>gM|@um3%P4{$OeMdO!@x`&5|fMb0le&QAf&jf>a>Q5Tm zpgUKy6u_nR<_Q-=EEsJ0{Z=TS=!~fv8DXQ|>g$=dRPvLN3*j(N{}tcMI$zwK$xqZ< zw(4L2l)u4Erck*3<0yBRH+6rtY}XgF+u4=WSONmN+`2J)kuUd>vzGf6y7nKaQ-x}g zNhp3j6QI52YS0y)y0F03JmYYmDxVui3duHO(qrQJu0vJJ{zGOhvGZgWdR730rV{&B zle2Al91oY>$M5EM@FJ1L@S`D+rxE!UKh7rUt-HV1yru6WZ|ILT>p)rZx_$Vi3a}D) z^!}Jx&|u8&wbba#t|R<-FxgmeO%BWVBa(^MaYFreM?7vHEn*Pvspr^LNy4ch$WPa-s}X1v+9eq-9HMg%PHbnh#I#@e0raO z9qcnsj6GFtGtv5@OpBvvmw=|};|<+cz$k1!((U!D@4HzWeQUg**p*;aR4hF_-fZ9I zIS|}QWEckc2&f2H;9;JE;G~{4u1_1o+m*GH8^ihLo~Qh1IB1H3CRPp()qyiXXL1@1JJG5&CV5&?O(NZf7M3;2CJm)GlTfq{cKj5x;3 z?B8{=Agxj&6oSuOBCh84HMU#WTzwD`QA~zt(q#wJ?fuL++~tjwU={YbtGv<~x94O8 zRFNF`7L#X}0@{7B7!e}GtGn9}?A7nLPXX#WLcl?or3P2enmCcNm@v?ecFRuB^PX^V zgSvtTiN_e|SPlF>_pQDDqz0<+zCD$7nNEEE_I#eZL7ScV*7L!p_=JS4xoy`2p0iSP!zH)6Te%P{BY#%0kr9|=`n<2 zB8GyOPMD5<?oX&ek?i=%jyD{RRv5cXa%qEog{co&7TSbD^N8+B zY@?S=!1uPY$}9$eU~QERUZHexF!&O#iu~eM2UeIl-FS!tsIU1|gSkexEM8r+DMp_V z&i&wnt2*qqTA%`mp>D8aw5r`s2>5DrBcucQ>IKpg4MUP5*0Dd z2><%-dGoP{)*XS^+?QCuh-o zCV%g?bAO^EiP7aP4y;M5`WVy4@9(lP`IV5Klt+m8k_9@#pn$PeNeS=X?9$7AArrw8 z=Iz|o{_HvdB(sMdK_r;w^L;r*>6?U1M(ko}ez}sBw%T;ioeW2ceT+!T^in^7BR8#0 z?iHj>Q!-LkVt%%Z-4^o@4ZV3pynB+#3XPW*;FEIf&k9}UcHZ=dedL(aMoUvUqJ#*u zbblaPPYO-JO-*HNoRVyKw)Pynnw^5N{qI}8By=KeXc&lxU6 zSh&}r#(M=Uf&t*Fz05hvjd{}ggUo%mLyH81$@I-0zr=ZZ8JM8wB`pF)2>|}c96b;d z^JDx~#%{(i zQJar%*7lFdH~_KmtWHE4Bukh1yYkAvs?2*;34-_#_L7Q0FUP-{mO{3X7l<4{ZFtr# z_InH^%QvoP{*|F1==@~Qp9m0Ixt1Dy(Nq=#KK^st&Oa1Hy8PB}xRecv(S^-&d@w|8 z+$`4^##%TU%eVZAbWG4AEZB7o0k!ms# zeVU%zmQ>t4A#jLTt$%{ZUF(d@gwf58BQeT?wEIA8|L3RPZ%fzS(95FA@q9PAaLrYP`vO1K>hp2jai5(SQHoHFNn? zQM&l|<-MKLS@jTFB&t|f_xc*nT|5{RCO)H6fACYUf%8um@T4_y?2L6C@fulh0uF_- z%&3*h|K_m1phlvKJ6HC4b5gg34~Z>my-c>)e+&b;R~sO|z(f$i5pI=JBNc*2xSy=` zCS>8@vWblA96bv4m@WuQeSF7OOJ;tn2X4+|+%c{Z-t{;Tw14zm5!4csk*&+zJ@|D| zxp`6>oJiEmgxYldKx0Rtu>X;ZOe$|t$W(_C{AEC^3n?pg-pEo^B#4-Nje8bC&@% z?pyl#rJ~;(a@zD699$=msx|GwFnxN?Vo(S}b{VBY*fh%hG)^a{l9+;_OjOSW3bAFM z)xj9zcqsaD`4ZBZhFBQ8x)`gWj2C7@zdTgj8L*Gyp`s1`!RdJWY(|MDaux@7Vu@n5 z@%v>GuW~~_$B_K!VRW^V3Fpzx@2X(DuiAl5APcufy=S(REa&iF9;zZHzgkT^R;I2z zg0O6gBvHn6;i>H%Wh*OLf*PeUx^UJWGmRf8T4F#LZ)TRS-_peoRDV z_vaZOYy|>o+r|#csjIgB;`ieQ~ULEtSKZD@q56#h(&~wLK_<-fIb` z_Tl)7+gflpIb0K88MZzE#Q#1ueP6GH81)h^ErUZ7cN zymEU0k-`Dfx@Wd#H*6-)6?*FuaJ~mChz1djL)a&XjyrlgXB~*XAK(_Hr#E!Rbe4r8 z4WbHD=eWN$l{TEzhE(;v{3#IOXOa1`VrIHGz^5qLnMS5hTRhN-c|rOqpCknJFUJ^r zAgFc3RZMTEsv;4WJzh~}S@Up6Ck<)J>yS?Ox9q9~n4B8?K$fr1?ZxgVO`V>_C(TNt z#<3^Ow&sZPo}*cLxK_7;Fxd>A=m^{n@YS#P79_Ebm=p8L@Y_b6QZ%10ehhrA1(Z}F z)KPN*YFoEfv8|;q4QT9e9f%$e1g_^FGn}xDRykfxJmZ)5yrE|q`dw6wRA=;(x`#R& zd96Qrf4ERer{_y==WWExS(K^B8hPF83hKra$U?U5SMbsLhnuO6@uWYEp{>20zQD{W z9ob#^9(SN9Xn+T5BTVK*e>4I)V)`-c3h1}AtZR+x^l09pOKs)8dpZaqjrpfQ7RHlf z9mJf2qVHBaHvs<5xg%}{xitD`_lkax;0V9CRFO?uAQyS9_*BQ!NJR}WK4znP&3)HJ zVmR;`E)O7~;(#jcYzzdT?21v|uJCEA@OZk0KnH z3ap9UbQP4~H2o+Dva_VeAr%H582W7K1~X!mKqD`B5$B~)ECXew8bBZvIF!+5;;b+* zL-BgGd)xpIyb#OmPl!ncn7pOv3%rupNc;isjm+^(Ew%Na$4{n0R~1Y12tcvTNQ(GQFN?|h0%MH! zv7hcHN7TT#hEEpad)>FR;unWqepe5WbH=YC*AAB9K__q9ydJ+5k+V|wA^~tqPWjxk z*@JiObV8h?%FMwwSMMNO4wy2G4&8NlnhkDXfF18$+7_gCpN;>`VfdNXBug=Q#kxa1 zo1O+I}Y5+mO{7QSut;dwlxDMk7`{b_j%>MwYD=OZniddFv_3Ib-g(Ag`k5QctNy(ltHR z0_9FwVM6Hc52Jv``I{8k9V=+8(m=3>3>*UkZb>fvtSG4+{oO2p>fD46kVAcsIEB}9 z8U9UoypMA;!^Mnc58(sB{o{OdI#{%BV%Z~}D5D>vdI<{p6(GDVM+ShK{bZNpS`S34DUH8@kgQQa@&-!Xb&BXHS2W# zI@6%YKPX5VFf%`_$;^BbbkV_H&0g<$e`otIVxhIHkl{@%4hL%X@Sfhxs4ONOogA3a z`LVWD--?Rb2v3;ANAe%GxEy%r#OG-KUf=Q`e(L$mvq!E`jenh@zlr@zL|(A& z{+7n1`)lw@NW}IZM1KSG@|VY)-y-4tgOp^j)uZ?yaC&2_IDOm1*8hjs$V~mRM}uaE ze+jN(>HkK`-(F>}|1SfQXPGm|w>}V5)C6E?=l3VKQf}n?nFw$*Z)*$eG>hgu`{D+2C8_u|M(El*Z8lHd zfJ(0VO_*prf?qHabXuVn_m0g5i;+&+5eLj(riVS_*?be##feG*17fmyr7gS$L7!Mq z55VA&l}zUOdiQ_G0uey6-noOayo5qKti=6|2K0AYS5G?D_lAPj1n*BpiWu9Eq&|6iXK;cV5I~K2)F$6=2SF z&^bH};d6(5()$;g)drpyfCv2e#Rdh`CvH3S%q{`+J`g$;AggSKOO0n_9@91d)e!tG zu;ry`)ViERKOij6h#rMAvw`N657%A8iNS#YYG0jxhn4J8q=+5IGpE2(U`#YSp*_5wVmlqIwKy8FrX1{MF-G<% zRXp9!kG!1OIHJFUp06tvmlKwy$#Ed+n^RZBnxd#04pDZG;LIV|j~%VtpM(jG55r{& z2_(whzPxaxB@j!}a(r=Rl2X4Gy6!7xh`5yUOULcT^LnRcvKn-|{Uzgc---sM>k6ZG zF<(ua>V4feOS#?~h8bCmP#O^`Ls7B_DpYDJ-$%Buv-z4nKMr`bK3=99c+PW;Zlp?Y z4IW$+bVpYSytdjl@_xt8jhf*1i54V}ARWZk&5r6p-N)eE8b}COx>*qh?QqP>uaCdc zr)5l!{3#<$D1x^>OoipH!=HzR@*}tKGIF`a(hv8!t+(z+NA&rwb6e)oeN78 zK@>vxE;2}h^JDh;lP4U|I4XoRsuE=fNeA2)D}MEAj!yK$2VbpQ(B@C+{F@rYPM)#Q zhOq{bP_kAsN6|o$eWn0Wu0#=2>3?Nsn1IqNS+35)>iFtv~I5gJ(GB8itV)Id4%oa+kO;KZ=WZ zg=LQunxx>3i~kD?vnl!(mpi`XYq>TM zTQ|wG@JQv6_eK{<6buR-$`1HJi8v4f2>H69btZ;ms^s21k7QgTi1n<9R>L=p8i^5! z+xTMEVgiEkoXpVVI@qP3k@R-T2O_FH@GN@?bh1Xa#{D~5nKPP62TaZJ7vJ)+18ndw zM>TB;|DoE7fbsp`QfNGtg63~2$`FtQG1#X$!bg3El1Rm59^ZxJi+)8?t+L`5XWxnb z-}eSiIjDeJ@;J`k9ZQrq#aJE!v-~T^`mbKpM8)ui8kU$4m>@AaJl>lgVrh_t_)`Ig zaE#NG%Lj)Ky52%*bS~9OzD@Bdw^kQQdxP6&;Z!u}0@l1h_caLDG1}xDb-@161J+?(uI0a1Yc6`i~q38L0Ttp+0hoSg&|H3q#jT7m{8Lj#?F zNbXCa_sQ@$RBm-|qVf1DQT)LEwfashA!82kut0Lb0|JCIIz?Cm^=RO^jQmqhVytl7 z%i#+5HuJS=)E?)(mmuBjuxk@T4od$p?rLjY1nyV%eDm#_eJQ2Bd-77O6fc<|D+SU1@eA*9cr zZykDa?Tm0&2NvT=vkU>2g9Gws^e~M#$_oz0H_(TF9N;z*N_x|K-1dG(o$?8=135Xv zu~E@EIh-)|^T@czPZ8JHvQDXoU{^<+lbuIHXiV2ReAs0OSunk{lzW&e`k#f z@caDtNLawzv)z*ucfPDD-+$X>2-F>P|7Yw*SGWI+o$u!v zsJWKp>!3~9e=F@TwQT<8sF=`AzeK9K z%TG{7UD6F^eWt^=%F*}Q&*+-L^gWm>`KxUIO2uK*HXEnAs3g6kGf9if|9^%4XN|kP zc?a19Whi{T+n)W)%lfaX3`SuD@zHdN10zoIR>9fEp~m8?k9?e&W|RJ62ATq173gDG zibube$f@2j$57r$0TO5Bx`NVxgo_DK7@d;_1P@Qm^(eS{IvD~l6v=S2@Zs#K%Mo%W zH!^^QYF77^_Bj}#B29-}{`$h3HfMfi{&4SgGKgP@$soPZMqRzX5D{m`qi!ZNFwtRn zbdKaO-GK(H1+?eM_vHqKYP`0IGVT^ASWuzoi=o-_Lq6KO{qE$U0r-EBOQIoVJEern zPKPoq1Nydw2~OAi`I{={a)AGCLD~n;J2Q7MH!jENHvR?+`r3rLxfgnc zM-0%jaiLJd6fpN}+?Kh#f1kv3z<#r8-qv2i<>Hd5GgCtG1!!r=NLO3x+Lc@& z|DQiA{LicSmwObEabqFP82yvm`|4$!`|w?VyR<0krzD)HO{xGf*@UU3TR;3C^tA16 zUJlOXoCZ zMt&A<-_^9ad2lsEov7{i_;^vcZv9$hDQSt&+AEp2&p`GI2b`$x6I-&rk}UOT%d9HD zNFq+4k@4^>YhcwWFxs<;eXGhVmvGWB`C;@>c8alLlIBm@#Eko4F(qyW=Yjw%V=4`i za&O7TfmwpQ|JcAcA=YV5&we;#Q@ugcusQ@$!cw+eVv(X;GUmBtF1GjM;kRY~&57Oy ziinm$@Awl3DJGwB@9sT}yR0IBIphZeKEN4~@XB%PW*}9_6L5k!IieX@b@9xwTFXKv zDx`_siwQ>kNQFmudfvWlkKd$e&-s=>wdltN+rh9DyB5+yszQ+PQ1krs;aO&lL}?^z zqvk8GWeyD=PpV-QjB8CqMd(caN-nVVQ!s*wN40D?brE%KPMgF3k^vOY0D=g|7`<9r zh)pOZMi^(uPyL8DfvW{Op`1jkUHD*y4>$1hJYB3*O4M*^i`MplORK!N9S9K8j^%yx z0yE3}nAHDNy;MH!WtQ|uopP*9rLUZx1n{?)OhFWkuKo)5baF`J)MA%xUuH=rzX{0m z7qjPEOayTLY!7Cf9P#*t5=YdDoB729NBH;aa~dTNd30V)rrBrDa??V{JsVFs)h7gG zX_6=56S0^)7P>p`+Mg_byF4cl9zB!ij&~mTl-@T6!7u;pER}!OfR{vm0W6t$9gWuT zl)3H;K4)2D+GpC$?Mn&7@}6dr7oVGt={l_l9ANgL?qM)k@}(1hiL%Dl`FOlFs_~TH z299oD>jrioLLF1l3CCE}|Ldath*CBTzW+%J=4 z7gjc)B_3CHR(%4$&9L0~m#h1EdjRRXotZuA_*N zsxr^zdEzD!(-aZdW1=v&zc@5v&Z5c&ReTcw<9O{XJa9k+W-&t5Ay3;UY{VQTry*3 z_Iw}E^F?EW5$Q*NAitM2V5`UJ`jkU1liu48;wO=bIPbJ-88dG_ly=;Uc^&|m8{7OU z2dupy?#qXKPdiO(0HA(n<}8d{!>RFwsD3>uTu(AvQ4q){ASR{Y7MV+rcuvfVQG=4D zzpZQvxyrZ#5lE~_zNdL6{4SJ*VAD{y@2NEWaV&kaLMHSERp?7SD)pkRbquhHRTM+E z))&>NYcLQOO17Z6^9ixdNhtxtg44NIIBPA6vxo6yqM`%Rs2pvHeQ#m&u$!<-C?n;z z8OxJ_q|noV*2JscZ)_mkEpB+0`89&N zrG@L~+pfYNpHasDj5vTb$!FP`nqq@R0Go8nTQE0emiZhbwzLL>sO)zv9-Wt0B}hgQ z;mDoyi<)M?irs?PVmlIAJ=F1ASpy+_=9SJDAdMUtw=m5?$Q9v5As8f?v3-m4(N&ZJ zvLH}{!VRJlPPXL6j2WFav0d*!zpZD>0iYX2rMg{4Oc5n_FHM5q7M-1#J=rnPL&bw zQiqWdooIkmm1r!niVrVE+&+S!5TI412+}X^in+PX{h9|z+x2t2Gy)V$9Z~AEkn2DZ z!pZz-1`rHz5wf1m^v(-wP3F--5kecDgU4TyUK45YZ|v$1@qgp@Bsye|qODWabm00^ zW;2GU=msP9r7#qJ<494d@UF(lmVNtSRF8J&Z8`HRU4m$Sk7$2V)s{%D+IR60%285;2oFRcHa?DXkb&~r!0q!B5LBQl7sL z#%)j;UyWbOs7Ri{$M>B?$%le?KO;~KL~qp*3X~GX;+Re?yko_1gcB$%NOF)wLAF#@ zwU`9Z6wvh7GVT87hewJKO}Ypm-jr}B;aRqPS}7p7QQ5Fclnjw1|HI^|GPeAA#eVAd z@D+$0k!kYfjqV*{`L%w?6fNz8QBKC8eULj}wBsYe=2}3nEk&j^VWziwaDT(LfS5XM z7LrUKD<0(l6-CqrQP{V*w|Fs>&-qh*3|m^c>jn6UbC@2x2w0xpMa{XZ~9$rq5&Os z+%VT%-yq&MHX&BMAu&AC~@0l3GA+BtPHyi+S3XGKz)O;{CBDLg5OwZ$-0Vg9}? zD@0E%gh&{nP;#7DDx<#HjAx&_uuadfoM(R*vO0pc#&%i!JfTLqU#*D+iCu9oZ$vQh z%egfdQq}lMnTidY^)hkBHCLeG+aZPATDpjB?hKa1kGF-Za!;7IT$uB6PIhD4?l2uG zs-;IaRV=l!*VgyD)VrOmYr*CfB}|a>Fv8*Z)IQW_bD&G8$GEnE9tkcQ=GWYLE-wU zx3P8@h81Go(O;IQ_+A9Q916^fwfn5|#{8H(69C;IwO`&_ZC{doV?j4-Cx_=2Tn$`Y z<6SWOdh;$!s@2m|v+&lRoTal29TOqzjV5ig!+@2F*yvAF_6W85)=7|^fKH#%fY-I} zyFbVnb6@HGxLVt@QkmX5NuK+#k}T$1XTh`5#rs*cQ#LCZDhxOzODDhQt?X{|7R=}* zA0;(2-!9GjQXBFmxkkd$O(j+9J@&+0sn*l~me&7F^A8^rZSk@#|Kd?d_?(gPWbPO0 zT$*J%__}%4@v2^zl7f=;W7^L+)|S4L6QaS~lT&iw>bpya)S^r?2(FP3?Fn^ + + + + + + + + + + + + + + + + + + + + + + + + + + + 8.2 Building a Heap - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    8.2   Heap construction operation

    +

    In some cases, we want to build a heap using all elements of a list, and this process is known as "heap construction operation."

    +

    8.2.1   Implementing with heap insertion operation

    +

    First, we create an empty heap and then iterate through the list, performing the "heap insertion operation" on each element in turn. This means adding the element to the end of the heap and then "heapifying" it from bottom to top.

    +

    Each time an element is added to the heap, the length of the heap increases by one. Since nodes are added to the binary tree from top to bottom, the heap is constructed "from top to bottom."

    +

    Let the number of elements be \(n\), and each element's insertion operation takes \(O(\log{n})\) time, thus the time complexity of this heap construction method is \(O(n \log n)\).

    +

    8.2.2   Implementing by heapifying through traversal

    +

    In fact, we can implement a more efficient method of heap construction in two steps.

    +
      +
    1. Add all elements of the list as they are into the heap, at this point the properties of the heap are not yet satisfied.
      2. +
    2. Traverse the heap in reverse order (reverse of level-order traversal), and perform "top to bottom heapify" on each non-leaf node.
      3. +
    +

    After heapifying a node, the subtree with that node as the root becomes a valid sub-heap. Since the traversal is in reverse order, the heap is built "from bottom to top."

    +

    The reason for choosing reverse traversal is that it ensures the subtree below the current node is already a valid sub-heap, making the heapification of the current node effective.

    +

    It's worth mentioning that since leaf nodes have no children, they naturally form valid sub-heaps and do not need to be heapified. As shown in the following code, the last non-leaf node is the parent of the last node; we start from it and traverse in reverse order to perform heapification:

    +
    +
    +
    +
    my_heap.py
    def __init__(self, nums: list[int]):
+    """构造方法，根据输入列表建堆"""
+    # 将列表元素原封不动添加进堆
+    self.max_heap = nums
+    # 堆化除叶节点以外的其他所有节点
+    for i in range(self.parent(self.size() - 1), -1, -1):
+        self.sift_down(i)
+
    +
    +
    +
    my_heap.cpp
    /* 构造方法，根据输入列表建堆 */
+MaxHeap(vector<int> nums) {
+    // 将列表元素原封不动添加进堆
+    maxHeap = nums;
+    // 堆化除叶节点以外的其他所有节点
+    for (int i = parent(size() - 1); i >= 0; i--) {
+        siftDown(i);
+    }
+}
+
    +
    +
    +
    my_heap.java
    /* 构造方法，根据输入列表建堆 */
+MaxHeap(List<Integer> nums) {
+    // 将列表元素原封不动添加进堆
+    maxHeap = new ArrayList<>(nums);
+    // 堆化除叶节点以外的其他所有节点
+    for (int i = parent(size() - 1); i >= 0; i--) {
+        siftDown(i);
+    }
+}
+
    +
    +
    +
    my_heap.cs
    /* 构造函数，根据输入列表建堆 */
+MaxHeap(IEnumerable<int> nums) {
+    // 将列表元素原封不动添加进堆
+    maxHeap = new List<int>(nums);
+    // 堆化除叶节点以外的其他所有节点
+    var size = Parent(this.Size() - 1);
+    for (int i = size; i >= 0; i--) {
+        SiftDown(i);
+    }
+}
+
    +
    +
    +
    my_heap.go
    /* 构造函数，根据切片建堆 */
+func newMaxHeap(nums []any) *maxHeap {
+    // 将列表元素原封不动添加进堆
+    h := &maxHeap{data: nums}
+    for i := h.parent(len(h.data) - 1); i >= 0; i-- {
+        // 堆化除叶节点以外的其他所有节点
+        h.siftDown(i)
+    }
+    return h
+}
+
    +
    +
    +
    my_heap.swift
    /* 构造方法，根据输入列表建堆 */
+init(nums: [Int]) {
+    // 将列表元素原封不动添加进堆
+    maxHeap = nums
+    // 堆化除叶节点以外的其他所有节点
+    for i in (0 ... parent(i: size() - 1)).reversed() {
+        siftDown(i: i)
+    }
+}
+
    +
    +
    +
    my_heap.js
    /* 构造方法，建立空堆或根据输入列表建堆 */
+constructor(nums) {
+    // 将列表元素原封不动添加进堆
+    this.#maxHeap = nums === undefined ? [] : [...nums];
+    // 堆化除叶节点以外的其他所有节点
+    for (let i = this.#parent(this.size() - 1); i >= 0; i--) {
+        this.#siftDown(i);
+    }
+}
+
    +
    +
    +
    my_heap.ts
    /* 构造方法，建立空堆或根据输入列表建堆 */
+constructor(nums?: number[]) {
+    // 将列表元素原封不动添加进堆
+    this.maxHeap = nums === undefined ? [] : [...nums];
+    // 堆化除叶节点以外的其他所有节点
+    for (let i = this.parent(this.size() - 1); i >= 0; i--) {
+        this.siftDown(i);
+    }
+}
+
    +
    +
    +
    my_heap.dart
    /* 构造方法，根据输入列表建堆 */
+MaxHeap(List<int> nums) {
+  // 将列表元素原封不动添加进堆
+  _maxHeap = nums;
+  // 堆化除叶节点以外的其他所有节点
+  for (int i = _parent(size() - 1); i >= 0; i--) {
+    siftDown(i);
+  }
+}
+
    +
    +
    +
    my_heap.rs
    /* 构造方法，根据输入列表建堆 */
+fn new(nums: Vec<i32>) -> Self {
+    // 将列表元素原封不动添加进堆
+    let mut heap = MaxHeap { max_heap: nums };
+    // 堆化除叶节点以外的其他所有节点
+    for i in (0..=Self::parent(heap.size() - 1)).rev() {
+        heap.sift_down(i);
+    }
+    heap
+}
+
    +
    +
    +
    my_heap.c
    /* 构造函数，根据切片建堆 */
+MaxHeap *newMaxHeap(int nums[], int size) {
+    // 所有元素入堆
+    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));
+    maxHeap->size = size;
+    memcpy(maxHeap->data, nums, size * sizeof(int));
+    for (int i = parent(maxHeap, size - 1); i >= 0; i--) {
+        // 堆化除叶节点以外的其他所有节点
+        siftDown(maxHeap, i);
+    }
+    return maxHeap;
+}
+
    +
    +
    +
    my_heap.kt
    /* 大顶堆 */
+class MaxHeap(nums: List<Int>?) {
+    // 使用列表而非数组，这样无须考虑扩容问题
+    // 将列表元素原封不动添加进堆
+    private val maxHeap = ArrayList(nums!!)
+
+    /* 构造函数，根据输入列表建堆 */
+    init {
+        // 堆化除叶节点以外的其他所有节点
+        for (i in parent(size() - 1) downTo 0) {
+            siftDown(i)
+        }
+    }
+
+    /* 获取左子节点的索引 */
+    private fun left(i: Int): Int {
+        return 2 * i + 1
+    }
+
+    /* 获取右子节点的索引 */
+    private fun right(i: Int): Int {
+        return 2 * i + 2
+    }
+
+    /* 获取父节点的索引 */
+    private fun parent(i: Int): Int {
+        return (i - 1) / 2 // 向下整除
+    }
+
+    /* 交换元素 */
+    private fun swap(i: Int, j: Int) {
+        maxHeap[i] = maxHeap[j].also { maxHeap[j] = maxHeap[i] }
+    }
+
+    /* 获取堆大小 */
+    fun size(): Int {
+        return maxHeap.size
+    }
+
+    /* 判断堆是否为空 */
+    fun isEmpty(): Boolean {
+        /* 判断堆是否为空 */
+        return size() == 0
+    }
+
+    /* 访问堆顶元素 */
+    fun peek(): Int {
+        return maxHeap[0]
+    }
+
+    /* 元素入堆 */
+    fun push(value: Int) {
+        // 添加节点
+        maxHeap.add(value)
+        // 从底至顶堆化
+        siftUp(size() - 1)
+    }
+
+    /* 从节点 i 开始，从底至顶堆化 */
+    private fun siftUp(it: Int) {
+        // Kotlin的函数参数不可变，因此创建临时变量
+        var i = it
+        while (true) {
+            // 获取节点 i 的父节点
+            val p = parent(i)
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
+            if (p < 0 || maxHeap[i] <= maxHeap[p]) break
+            // 交换两节点
+            swap(i, p)
+            // 循环向上堆化
+            i = p
+        }
+    }
+
+    /* 元素出堆 */
+    fun pop(): Int {
+        // 判空处理
+        if (isEmpty()) throw IndexOutOfBoundsException()
+        // 交换根节点与最右叶节点（交换首元素与尾元素）
+        swap(0, size() - 1)
+        // 删除节点
+        val value = maxHeap.removeAt(size() - 1)
+        // 从顶至底堆化
+        siftDown(0)
+        // 返回堆顶元素
+        return value
+    }
+
+    /* 从节点 i 开始，从顶至底堆化 */
+    private fun siftDown(it: Int) {
+        // Kotlin的函数参数不可变，因此创建临时变量
+        var i = it
+        while (true) {
+            // 判断节点 i, l, r 中值最大的节点，记为 ma
+            val l = left(i)
+            val r = right(i)
+            var ma = i
+            if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l
+            if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+            if (ma == i) break
+            // 交换两节点
+            swap(i, ma)
+            // 循环向下堆化
+            i = ma
+        }
+    }
+
+    /* 打印堆（二叉树） */
+    fun print() {
+        val queue = PriorityQueue { a: Int, b: Int -> b - a }
+        queue.addAll(maxHeap)
+        printHeap(queue)
+    }
+}
+
    +
    +
    +
    my_heap.rb
    [class]{MaxHeap}-[func]{__init__}
+
    +
    +
    +
    my_heap.zig
    // 构造方法，根据输入列表建堆
+fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
+    if (self.max_heap != null) return;
+    self.max_heap = std.ArrayList(T).init(allocator);
+    // 将列表元素原封不动添加进堆
+    try self.max_heap.?.appendSlice(nums);
+    // 堆化除叶节点以外的其他所有节点
+    var i: usize = parent(self.size() - 1) + 1;
+    while (i > 0) : (i -= 1) {
+        try self.siftDown(i - 1);
+    }
+}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    8.2.3   Complexity analysis

    +

    Next, let's attempt to calculate the time complexity of this second method of heap construction.

    +
      +
    • Assuming the number of nodes in the complete binary tree is \(n\), then the number of leaf nodes is \((n + 1) / 2\), where \(/\) is integer division. Therefore, the number of nodes that need to be heapified is \((n - 1) / 2\).
      • +
    • In the process of "top to bottom heapification," each node is heapified to the leaf nodes at most, so the maximum number of iterations is the height of the binary tree \(\log n\).
      • +
    +

    Multiplying the two, we get the time complexity of the heap construction process as \(O(n \log n)\). But this estimate is not accurate, because it does not take into account the nature of the binary tree having far more nodes at the lower levels than at the top.

    +

    Let's perform a more accurate calculation. To simplify the calculation, assume a "perfect binary tree" with \(n\) nodes and height \(h\); this assumption does not affect the correctness of the result.

    +

    Node counts at each level of a perfect binary tree

    +

    Figure 8-5   Node counts at each level of a perfect binary tree

    + +

    As shown in the Figure 8-5 , the maximum number of iterations for a node "to be heapified from top to bottom" is equal to the distance from that node to the leaf nodes, which is precisely "node height." Therefore, we can sum the "number of nodes \(\times\) node height" at each level, to get the total number of heapification iterations for all nodes.

    +
    \[ +T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1 +\]
    +

    To simplify the above equation, we need to use knowledge of sequences from high school, first multiply \(T(h)\) by \(2\), to get:

    +
    \[ +\begin{aligned} +T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{h-1}\times1 \newline +2T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \dots + 2^h\times1 \newline +\end{aligned} +\]
    +

    By subtracting \(T(h)\) from \(2T(h)\) using the method of displacement, we get:

    +
    \[ +2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \dots + 2^{h-1} + 2^h +\]
    +

    Observing the equation, \(T(h)\) is an geometric series, which can be directly calculated using the sum formula, resulting in a time complexity of:

    +
    \[ +\begin{aligned} +T(h) & = 2 \frac{1 - 2^h}{1 - 2} - h \newline +& = 2^{h+1} - h - 2 \newline +& = O(2^h) +\end{aligned} +\]
    +

    Further, a perfect binary tree with height \(h\) has \(n = 2^{h+1} - 1\) nodes, thus the complexity is \(O(2^h) = O(n)\). This calculation shows that the time complexity of inputting a list and constructing a heap is \(O(n)\), which is very efficient.

    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_heap/heap.assets/heap_pop_step1.png b/en/chapter_heap/heap.assets/heap_pop_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..1f26ebab1789907f78da8d7a7be865f217c7a8a0 GIT binary patch literal 20561 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_pop_step10.png b/en/chapter_heap/heap.assets/heap_pop_step10.png new file mode 100644 index 0000000000000000000000000000000000000000..d831efbf9b9b71b1ce095abe7a90be4f45e5f568 GIT binary patch literal 25204 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_pop_step2.png b/en/chapter_heap/heap.assets/heap_pop_step2.png new file mode 100644 index 0000000000000000000000000000000000000000..a9508de71728153310a25cb4d77088aeb0f06383 GIT binary patch literal 20925 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

    umSa68CIDh+ICUevw!j(-E4@iXbJvI&6XGpM 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_pop_step4.png b/en/chapter_heap/heap.assets/heap_pop_step4.png new file mode 100644 index 0000000000000000000000000000000000000000..3b3a7d25df94d7f9ed17e4da9b4346e1a8b10064 GIT binary patch literal 27314 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

    ^#rRD)ow*yYic$SZ!zmDDHBo#t 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_pop_step5.png b/en/chapter_heap/heap.assets/heap_pop_step5.png new file mode 100644 index 0000000000000000000000000000000000000000..fa5d99b154267f54f7cc3134622db49eb38eaff8 GIT binary patch literal 28857 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 UGMEx-D)mc3T-Q6j9`Tqa)KHYiP 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_push_step1.png b/en/chapter_heap/heap.assets/heap_push_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..26c5fdaaccb8da13129b4ef28aafbbbcd369830f GIT binary patch literal 17672 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¥JK|x9rvjBk?OR!B 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 SPxNMh1Uy~+T-G@yGywqryu)Jv literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_push_step2.png b/en/chapter_heap/heap.assets/heap_push_step2.png new file mode 100644 index 0000000000000000000000000000000000000000..e0fbc7e8347ce66642c6098a34684f5653bf6589 GIT binary patch literal 18674 zcmb@tWl$VZ*EQNRgS#`h1a}J-f;$9B@Ze5@27(0{T!K5nArK%0x1fW&1%kV~BoG|# z@I3EZb?a8$@5im%KW5J9z4qE`?{liFyU*ze4K)R93~~$r0I-!5WnTjTGNK6{M}r{# zt_nCU0RVKUp{gbK`1lyu6tK0mb#-+mS$Gf;5dmL>zj*N?e>iXTc%{9){r>(w=hwyU z?X7dm>Dcbg!NEaNQc`4OgH|goH$AXJ>bJ z_us#NdwY8)CME_32CAy6f|>*W{P~lYmsea|oRN{Cudlzkxp{GMF*!LoG&Gcxlk@uZ z>$$nP)U?#lmXN;HJ{cLA)6>)D=H{`nG2(!snwpx5$?~G2qRY$6`T6{Hny%_RZmr&{5v`RcU(VH z*F4v}c(@pn6QcV4@XzI+x7Ejgul@#?1QkzTgf`6eZC!IjjRsZ+UfeuXFI-Bcj87lj zM)d#v)Ny9pc#;ZVNE$hxT-x|PupE{W=2tUoUiiCnYSlim;%oI+>ee%F0Fducl9kf( zoImUcK+FXImU~}9S^|D*{(n16|E)^?$Fu*j4qr?A|8&gOSWF4$)1q~0D^2*~uE0@e zwE`ePywDw#0Q-&ZT+jGpPMx5*bN52+#asUYq(oBfd)Uyg61D|xB}{-zPWPIa4-am& z`{Vj!!`I_(RD1wy#!C01I?RC-AI-GB`u%&qF(FAM3`RV-y^;IZ<3B3NoZ!!IXkjJu zTuNtEifqb=rny3-`ez~nJhr-939V@)c~f#$j76JrD9eh{sd9?rL$7l3 zx#vYbEq2$ivzK#!>V3pbF-r0M`6(^^{^VE?f+yLsj|KONx6@uq*!%)Qqctwg7kMvb z>F4r>;QNLeX;b%O!I&+x;xLEdL1MC*Bwx3VQF646(TEv z;Vp09Xp1AE;MItR!QRqy`}s_XQc9p>)6&h`FFKEubm{Y0Kx@&Z6UE(CGG*K41 zLY4vsa}Cf*b;Qh^=p8^O|cSS^kBNcI zlLqGvHq_Cr<)1X@+0*-wE*k{@v+{?(Yis-n`I`S;hK`}vdh#F0L47%ZQ=(q3n>AMq zL~WAD)=twAB_QwR{(O2ZRzix4D1KQ0HE) zFnOcI@qsH7iiHS-!@koO1csW^$1h&z%FvqCxMqgH&kREAH4ysb99ov;d}X+8fiHi8 zkkHTL!xV+WLlkuC)tPI1@%CU54_$e$oavzSu6!s_p=@G@?J2Qt8B$T?cmWPsq-xNDikEx1Gij$NE*FPT{AGBtkZHU7@ z)DgdTuwHXbp5ncs2Z%B%r?*MPbgue&VP@h+4oCBY~={sHp1L$*$o0G-Q zRF;xQvLcx_U@<<2#`6)5nVYiof689@wMC=mDS<^-t@!h5>IyAW{LvhRK1gh9Q)Nq} z_15C4jW7A2w0b%pMi$QTOGo_v{*bl*-QFox8(5nZw&hbp-l~RWMaw6ze=We>$WkOk z3XGQf)*_pdFA*J^vd!O|NBrT(=FJ6G_GNWPgb9Wtb%Ar`EsqE|s)`@z* z=7Y^xyzQj{54XSHtY&kC;@O{(g-1;=NuVw($5)3*{zP^E^Bj${i&;KVG~>h-AK?~d zhdP%U14jE?*10z~xR;t>1}0+842d;ogv9f<{d>^$5C7adyva_cT-*Dew(N%`EniWV z&mK7k3|!jqv-<@x4=>VU?9I=L;3 zLLIHzmSP5Q>@WI5+kD58dbBR!VfLu` zq&%abZkpfV`Ruc*uYst)*j^V%eGdrqqz#Xt6)=gU50_^3izm@U>Vb5$|4xtIV`|Q@ zRMv?fxEr^2D@<0{HnX;Q^9m~<_<)=J&^{nOnaY-Y{K`rA4=`2cqlz^!G+6%kEl-?M zhgR+x&DmqD!rPBq1xLd|ybN57`)boBX~mM0uwMVJxeb=12g+7mai-A9X9ov_aYfTJ zGn~QE{X;MNQxY#ollPWj)ZTx7@kCk9h_f|Ikd}`&w5ej5iEKYtoJqUp>)c=e(EdPi zM8EJI#2)riHq%Lf{BK;$ma(e3q2c>9YJmi^A@n1h`_ZxP@gKlgFNvwP;qj9Hx{c5u z1Cpvg!^w=nRF>Noact%ckMgmm(1D|e!#2W|37_>0r~&n;^6=s*>T_Otkwzjm_}jV^ zel+xH|Fh~Pa_3D-ekYPsGGQp%1g0o^=`^lw&y( z7;Dr&21i_LJd1sFOyY{SAg;&`#-wx++%Cm#$hg@#W35~*#*dQjTz`zt z`ONM>i8yWDGY&~tQJLjU7}`qH_wjKZCCZJj zrH~z}%m~XUUlKXG_c{p&IS1HI2el=ckBf)2A$vZUCpO-#k5$6bkWFbXemAUKR%L+^wUd-YdF1S;Q>`^Ts2V(Xp<rHcGD+QOInol=?R|?fR7O z7KaE!dwWhgFZZ@R=nR*VR@8@Dd|~BkuKuVAcFt<55=%%GRzzeD4I~P*2ru5j zK!zT|p80`G6hTFJ8+<||3OG_sKPNvzdrg1Mg#R-SI|@FzZ=Q8Yu>F8xuus#)^EFow zc2Nko`wd={^nTmIau`tY;mrspsi`-=4aT_Ql-L9v=F#E!NCnIzd6%ws>P4uTQl8az zvX;&EKD$Xl4S-*nkDM0KjC@6P#aF5YOSx+j+6?n)1bAIy7wjHPOV2L#!@{@o_R%KV zh;930&350Q{iMn4;lehA>92+vfXWA#>;4QI=3tQ0#_;_Own|RZi|Tpf4(YNPRV=?(?kx$QhL|NkA6f_F~*7 z8>5Kni;rsGJvYmTXb4Hmk{`dggNBMD{{~}evcVhR9(CZBUTKhUZ)e0muvnkZe(_IK zTZUp)fg>~0KeFV0H1raodFpiW;HVXF`{gD-58K;S$j@nJA9|q<3tQ2iw&o%r8Yvoo z;^Sd&hp#N=coa?7__y)zz-K8?TV_P#Yy%(xmPp2^)JU$=4X!lNF>}Cx5AIXmmR^s7 z7je6waJ~sX_nqueC*(xlG@>SA(}(M<7s;!ki@#rN;R8FLVHY=amHzI>_U+)shp4dy zmlfjYA!_V?lSd&Z9GKj{B(r@l6y*BBVs(`oHq<71&;%hX3jd*x^yFQ~M9dK}((Ha% zGC9&SU_)yqoWcl7*8%n|Phv0L7VfcUjr@^Gh6^9BSaSk2S>RQ#NT$avf9uU=N}f^j zr#k8ZF<%-w$&}9gYCME~ypq*~_TehwfD*lU&wjLZm(G@IR*e&V{g@|TsE91b<`_9G zXD5`8mcPpEyeEBMKl<{Ai>Oi`V#1}r*ttF;lDksDO&`d7(U5*Cz@(4N{`)U#f|PGa z5UOc2*XRn_;hwl4;*mhdE!}!Up&{JV7Vvv^V@$#4Mmb!X$=mpRcYZnPVEJvW&Wip8 z3q9m?gz#^``QJoEMPSn2->A^Vi(920gNbZPR}nFOz2l?vFZsB#QoD8=Hr=LTC-e?~ zp?esQ0&%%zY)yLOBu*GZL=serxKdu+gkvuFW%$+a^5^ z7?ya~G7EH_ilpaVM%g~U=^=P&6t!*2$O{A+43E*AA3W;9F+W-`e@$a_J!@9Q$C9i( zthV>3k}n}$X9&8%V1@9E8h-M#kIPhE)l_$!9oT%QsmkL<|8O$TqufUBx@`EG`GI}Z zxPsfA5aRsFVO0R6YAsja&U6;}Q~OH>_fvtoaNx&(wre!9b&MDH@EuxTy2k9DukT#n zC-$p*F&hqgz$^0P_c~DFnc>&8%9WGU`ypmwj8?L3b%At2{*`a9&7IDeX2#(gClZ zLt;YLCR`(IX#+5fY2+|3UQy7dtaw{y+P>=~CL0J*s=!JKP)3Oma0bHrATV~9#?&x+ zSBdrAlnKISnV0^Lj0b)fWayxJO}ssr{<z9ymKr8>{3BnYB>f++5?650XoZ%g*LQSwr2k`4 z;R8e73HnNW@ol4#9VY6&3u4{!yKnk*y({oElto`gmQH+vU@U0hmA#krpz?Q1t| zX-}l@Bf`vlq9iKmA8qtD@d?77)Wt~hG$J{g-$)(XzieNywhl8Hq(#gvV7%Afd8Zw z8$>4B@|DO}XdnA9Us@dI~{uhwUVQevNlkIxY14R@cV41Yurm$T2O}71J z6YswPhN|zamUy?3Q*}E2@v$I;59@DFzp1X+pJtm~!D?a$Somijs*h7tzMBSNm9hi2 zuB<=rtv=EnLq*n2P(~1GpT+Qdu&8aZ>2UOC^xkYahu&L2yq|37`J;eRtP2i0cHmvcK+tjG01k{Rs7W2`E^+Y3D= z$p1Z)j=`^Mn^vt|nTN%O5K%Mi6HY2_b92)36SEH8 z4tbk#9Xjmom9M8)HUa5J75anAnA_>p#M2$bEYh-AuRvlFfn%SCkGLBa(=F^@o#s|qq@^QHQ~rSnQ)K@+ z;-2B)`M3D_yQx1}SCs0SAp|jOKV5zrK61NnTg_NbAq^2>;J#JSU6TToy z8!11))zToV;|DOyrc{k{cDzgtifSbm+i|i;i)PJq0)%o2QXzb9nW182?s@S>RIz(y zf&12J@&@u2TKNh*pU~6#zNG2LFIehI$CljzYA7BltB2oBFOg!e51`iO7+lCatobQ3 z4s9YQfIF~PiS}9O9$-5U6P6FB#x*7QaKKq9D~OJ-RDB8&Cab^tmzq(2!l#2TwtZre z7Q&jz2;1v|gG8L;j!}6iyPdT2)69$W24jt;u6V7{bEl4m;*8e1#%*ri6rp&j|Bir_ zeLz1TGd(Tm&i)WR%iRv6^xV>O$fwf%mpTDO-?@87>jp=_`)RhOIk znmtGiEy9@uE`!hb681w>gWD>Kevs$axp_}qU}r3O)19yrx~X#s_kkG99h*fUSLrob zoZHK$SgnEyjZlywijLBZJo7tTQ-};UwPZw$%GhlxoN$B7qS*scxCM+}wpkntvknMl ztXb(d=X&5+N%FTozzVUKe%0_k)>Segfo(s;-yiMu)p7Wsu~+FZGc32a=Y~uh9vg8XgI_3fLHVhJnETb za3Yk=@(+lylNPhE|2_L4I!n6v(X~qtd5FSeNeq4lE%HVLUaiqc!BB&w9be=on6V>= z54oudH>-zA3o1jf^;q5VPrM(+LkF0?OUKA2j#$6p+y6~Ow{N05pwa1?4`p}{TUuS?ia8rdS#Ee zdFH0r5B7R9R{4xy%RoMK8^ZdbSEkOmr;75VUmjW-qjDcav2y3Sh}a(bOqrBmWc0&F zpLy0Le#a61PdrDYIDf1n3`wo&kvBXwbnbt0HP!8GJyZb+u_@m?`~<7$@NL>Q#w@U1 zwCb0$@{NDM>*nPcd#;ns!0!j|Cj=b6j*}t9C0yg7$QnC+MFAa}_TjEF3{Bdy5%FggI+NTNUTG=Yku7fvCbX zT>|PI(LgA1am1+8bH%Jtm77<+^e!sja94N2nh=jx7hLdN){{j8+;Puxt?qE@Tp>Xi z;;K;p35Kh&bqO3ak$-Jki>84OR1RTv)ULKMf46pPIpvlX`44jlQ11;RhxPos0>opn zd095p0Er1(yM)}fcNY+-?tJkN{0Xsc@C5aKJwVOaD16G);XsLLdKe2ZP4KtXc^;rT z^U0<;UY9%LbM2&cU_Po3+x7Caz7c)|m|kn-$+IUP9YspXG`}8*!OczPJ4QNXkM2!s z^_C{Yy#Tm8gyxHBdPm+gFyU{FS0QTzz4AEywpg;x5}Z_IN56k_U|OIjO~`z!JI^QQEORL4mh`{vgshLYaeKS>AnuC2pWt zg7`R3`pphOYS)~19y=w;?iMj-osY|@tFz@msj@t@=q5=AwK>3?@*Lbxf?22~g z+b`iCzp{k=L5U?^VKjZ;h;)dt1Fg5zYUt-Vaz(mCF9!=u7=IL080&-TAyI;VaZ?U*w64lyDJUQ9*&iM{1V zh3D{0e!Vh2V*K5KdquiBN~UsV(Yp<*yHZWV$z{897aiJnOKJuZBjFkBAgaH%FUF8Gh> z!K{DFpfu10jLQKW{mL7AinW{!6^_4RX03Qq6<_GHIMb*&ZJ zeK^=%4G46POCX+=@-Q8EudzyIG#+4m5hvI_k5M^a>>%-KPp%61)~J3)NZnH^nU1n( z{c_SD-fq2&6it}lC+P;O2@`#9#tYf9`F?a1UiOkEs(BKpe>RV>1ARz+1T#wwc( zw?86gj0RC1rGy>%=q>X{42sb0;MJ>L3=+^M#uLtGE;7TglpAzr1P zaBb~a24`y+f|_Lec<}D8aQF|JqEEx+qi+9^^u%5~HnA3s0+Y`mT_s>cFYk`lc#Yw2 z{#nhqAO@Es8F|@eMA0|-)|Hh?c5vx>P12kUw0c-2X%MiQ&B78@%z4+6Ghqcj-hdU_K z9d9r>(Cdz{rXu+Kk_8X+A`kFoz|9!-#HZ?|xT||RYnBo?(UBaOpj!l&pjW9$mGTxt zqQ}EHF6`C>$#qmg z*iR2Ql3bC?g>I8i-AJRJ5Zxp`qiw4=ACO+?5p&=ir%EOH=%F}KoC<>TfK*(~#ZO;q zxT)lGs17mIsLuHe^T4=k<{j*7&+>rBkS(wMvF8>y65q&S+e2FG5VI=PRS)7#ynMiKoO zuY}qqgKG zElrRVI&YFb=z`?bvR8v)H3RqKGxakxoGfB<)N80AIxmp{Xv__q-Ftp zXi*rcFz++m6Q5Hhy&1#Hzxt#OVHLC960{L-m?l)+5 zrO~}E7j38C+9jO0Uc7Rj#%5m!pJ{A`b#pa zCHt8@vWj+a-88}~qh8~7n*%Q>jF|*851Os;{Y&_9fd0D1K7V*V7MkNlvtw1ZhHN!N zW$|8pTUd*s5+={v4dKzoi_F7$l=_YFeJXECMN*CoCshBQ8pi1hBCXOU4=C{=Rf)5LwSHUmiDYp4aZWDp}TKNTzz ztcV3?HNI-ghWPzD0Nf;(P5_?`nol;T^ICYpXHH2C!{i?{CNh{I#w}^t=cZyhXtFFn zlN7n?i0nUW%&VxdlGGA;pK+5g@tX44K#Q`Z4kvQPi*0+1BIm~mmy+LExmmh@wc4#2{#oi@8OW_2U0QLH z{c-aAcmQbBvjQz5_r@cSfBOVJ*U<;KVF%Qhv~bb&hiEPz0d|Fag z7{bua()MSp$l}q$2D41*_3+?{W5N9#H*6bE2k;1>QlMi(aj+03!QFZ(DXlCP=!!%+ zH|T+5_9mSIzHc13Oc-nVYs+FcdjWrZ6mKR*S`{lua312K!~qMw>#B*+^_(T4 zRb^bF2YFjVJanovctkB++Bk~Ntk;7YOt`LLe)IeWDc8651Us9EUsh z7fS;u)836TBn?VnO*!_WZ0}hf`cGXB$A_q8+o=e0vFlH(Y9^iT@FH04Ze@i@Cs7 z(#2?Ne5f4dJ65<$c(ha%3a_OgELcF603_XD)F!igJgM9Nf%&IBmH~U{g)cJ`-6hUN zd1r82#5CnQmM0fFGi>u!DoN?6#>CYm*;PE@M`e}+Q{FNiI+bWBfj^S8V%HGPb$PiA z-=GDk9F{!uJgP+-j_l!I3`1RTsy#Q5)p#dQsXUol>|7gO;@{ zkw6Y;=&=7bmip;`+Ax0^(N#n#lE(*c3+-BRgmt28}9Hv8dedzfn*u5GyXlRpisZ6>UHMMk7{Q zN}8rQ-l3W1gICNm6H#g%+-=GcP51ruE;X*m%SfC1v8);C>(_VR{hGFA{~qR0VhGL_nq92t)EA-Aa1$>e4>x=&?Y8ir3%c6T!hsW!|zuFPVNY1$R1%x{@=dX{drF^DW)*|_mHgHUvx|X z5`q0GVKvkzTQUpJ_+IY;hUHiOQRLI%vj2RDTXjT0S!kS(3{}fNUCFQ&P7#r8#U2!d9m-$J?jKsTfhKehCJd2=UV`v0Pl7{^ngWht!jHGmA ziC;wljC_)^duLVlK5aV7L?8(PyX#t_u~jC&V*A%Z3D6yZ@gCAW z`aD{UuGF-e2p$2FkNa}Dco?D96OINL9lHh$&}aAM1&&jE0gvc@#SjEVm>CDi=vvHKs>%G8&Id#U+L0Vty( z1u*+5j#^<(-=J^T)>*k91vqy9Wk+U3x;Hzy`oy}pq~ug^Z0!BcuJS)tt7Ul2Wd+S0?tC$0tecnoK)C4=o4@)ANaDq!R>O&G(`(RH3-(QMSEo3 zo_b(=`oyxlt}3$-5#b%Ak8nIC`DU;%Iy_A={2yT2`(J|33ztn(5W!n|ESu|pdR?H@ z1lt3v4&L==9}@HB6pO74ai}goiKZIr( zEg^u7f1$s{sOHUVO9vMn1t5I;%$LShXV3TVf3b({=kJH-RKo73vEBbGeBNnKW##$B z<6o8j_rO);LR#AbB1e-asl>R|^VDg-DX<6;IaPQj&;1*$T{cZa2=M9Yvv;5w`CpUp z=(xLm{{NZ+rt5=hE>QZOw7t7#yFaAJdhO(_il{`nd9l&LX^VG|)l&(HEut5CnP(_C zp6I{pA@*oU7A%{lBj^o#-qq9-zq>#gdg9pc-Krmwns=HrO~=EIk^$^rD#mW0*w`&q zckm-p^qg1vX0^CVPt{<5`V=Jl_-lj9=TCcfT_}@J?t60H$IX=wx<%+-bbz`G>ZJRa zmJ`pbCnVRes*@7^)((NSc>w#&N!=QTwu~`zHfk!SI9NYeT_>j8p3S~WboR;3F7ruDR zwDi9{u7Kpv&p~Zu&+(XpQSjGlkkpLINE-Rx(W;?g(|2y&d9F{x6-eKs33UBact0+g zc{-lkI!>=z9^ej&!eNpjT|2n+`MXbE_X=XuIf)=}!KQ?aG4sO%Ch zawISDv^A-ZSw0U&^t+~93w`=xrGJH$6ue=PQ}FEtS2YKg;vEo#u7#_ayp-RVrPIb>pSx(@EyVgq?Imj~KNwvkwPN#>ra4DXP)y_M z{bMc56D|^@#OxaNFH8IkL>L!Gh_0G$WV>CcA@G_W{83H{8brtHu<9{wg0d9 zXc;uRZvkBn7}+_#Lzb}>NNdQUUznytyBUY4dy^)z157vZ6#HFhDGYUmG3w_Cn;4$_ zTP)$>LJJA3S?G%WW@)7%%lNtjOrIRFq44}EjTIy;I+Zxbnx*jy@?|`keyQNn^yR?7 zM#69hq}S%fPV`P`u`mlT!Jk;YD7EXgKEjCrs_88&89PGOprOF3F$w#QJLcdxSDxn+ zFW2|k15|cXJY(}JBT})@>gVcJ$y6n!)jFJuFB=m^SI7Lta?Pf|RWIsJM2)ImifBsO_K#98bl%K5R}IE(Z44Rv zF;XPSoRe;C39Em{iC24ZVEiqEO~uj~w7l4UR^5PQZd%i0@BzIdkyS~IT30$9A5U*vTZdBVRVeu6d}hlFu6QcMCY*p4fq3qvBXS( zx!R&chemH6y~Zx^=`%RI7G*6WYI;ZI&pR1QLQnD>byG$pQ(NJG$Qop@K6f<1D1+7Z zQGYxWNqSUM4$Hpsq@%>H0tQJdTcJ_w(VtS%dCw2qLniSHOkzh2euoMhRoRLNnMfD$ z9==;Tu~%~xYX)kmW_k7%p0!XLNC81W^`e=%0W9()^BalkQhg31Bhji+}3mi z6e%jZ`NtQ7LAH+(rqD;q94fFlutlYpNQK?M$e|(w5)EQjV@VE`Jna_FawjoSyO0Ur z94E#e1Qwa#2l%t@rd`D}Rqwk|k#b4#pf?(#y1&qoS+KINywi9Fl0to@Fj}1eCEb_7 zvfp8=dkS@4%}_M8BAL5z8{>dgvdzIQb-S?^N_P(cgDsg@%wk_v4_Q7`AGem@xeM- zk~9Wb$?n;)x~^0n!hm7AODZ)Q7{R@5x2+B*fLf`%#Lmw28{+%`#J`{ggkG)Q#v>yp zR{}0NJm)ZL~A(?%D7?zH$IIGoWVX9dtMfJ2?t1UGj%s zK#Lf=Z)R&4M+2XiQmm={S|yH%XEV}sqCLvYi;O!m^7P?kLp3v#4iB~r_`MixCx}DM zL%%*LW=P~T<|4s_=+MyMEM0TKh*3?KoiCt`KlR$~&=%8suu|-(a~35O!{8a!^u`cR z2@_Y7525gbQ~yp}si&lfhAjKo?Z=1ztkfelLr!&=0DQidpMlxx>Om-p4%B%&Uy_Ie zB*ZYGO@=_*2vwl_m5z^eDJ{P^xnRqS*4uk~e=1iJea_X1_0vwXFm8z&_GHu~=Z**lpvphaO z2hCbjdr;nA4Wp;Ud7qu}VkFqg!zw#=W?Zl*N%7NQfB7rB5T;0c-e?bT@Md2hUZf@# zA+e@u|1caxE|3XBF99b8d+ro?1t24DK$+O`;TqFmaH=qf@HMKEYFC!}k4MrgRk_ng zFroB=onHc0B5l4`0KiHQUEuM>cL|c1jmGNWq>z+mqwm>PC}zp*v?&f12sP`Zrw?69 z9Y2N!UW@ujv-QeOS)#qc-#k;T3_Ppr=CQ-4laZ#zt&f55(2-&iYGNOb+UEeGv~Y&d zz0ctkqOlDfcN_Rn=~8LADU`R&$b(&7JTYeb^wOb!kPgS4L5hl2SH4-6qyzq@8m6Bb zJPM#i+~zrErvze4O|7>Q+cb2)^KQv`Vu`7U7#6G)D;dn+kQZ@FyCDFewWa~g%TxZ@WQf>PK{ z(FH=T-t-Yg(4l#>t$uI3j&ngmx>VjOx|9s|P;X*}R;%`UMOGDQ_TVX*6nBqkSmLSpHj%Dyo zn?GB`rk(Zi#N2dh@1MkHG)3jI_gzmxs`vXpeVYZhIEjgX0)bGJB0q3nj@=@vlzcO- z*8J(?@e*q8?(!Q+TD$xI|9^6i?{5GGG}<^um}Ck7)(4|mqW>Q{cosOAyL{moZt2~q zO_}r{BS+oP#G<_dRv0_ z{R8BG{{G)8Gg?m7%0%4b0!W0pj%{VK&ICt`&;{XP=-?YI28qk^c20y;PeAQ0xEJsY zRCvtC1FbY=EABf6G@J2N{b$OXCAMz8@as>wRw8zWw2}VrQS^LayU*luxzmGyn zBipzIS5Md`4@G`1BkBGadA!-?y*U1ASTZFoq_!cyYgl#38+Np{CH z?A2XuyXeeey|r!^Z}Gpv^TYW*bf-+17{|XnE2OGdA;q<(-Kh_!@!f?R!Y{|@V+2c5 z$36*oP1x|jh@g^zNvPw>Y!rQjo9W#XOk01DV@t=?-}+!E27+3|<>xzs$_AATd$HCn znI^Wr#oG8?|8(ScxP}*C@W3pg@PlVoznsAH!fK;65e2VGxBgNanVr51Lg#^PSc$`! zViNz_uiGY?Ut2<;rhpO;49N~RH{R`k&%e6{ApKM*aeOeo2w}Am{>Xw?U$$Bqcwh`r z_!$q(w(D68C==BnTKBDXNt5>5KH!gdUDSHZyeU9B-Uu>W@-moes%^MdF5DQfRywFd zeS5+Si&Ez-5Uvn}!jT26ffeG5{u+v7=Aq;tFFc0c8C*`EkB|JMf%mn#yEeEgzhwTs zJfK2B{cB8nO8n&59jEwAA+_14*+KE_-udgB!cB?LXQ*EVQNz|Qt@S+2q!;UO50nJI zwNk}z{Py--w!e(A+E*_mG|G0%SfQT>9-w3*`$UHAx5UuCm zfk0bb+I^P_vJwj#I_;<@|L_g}ywf$mbMw3xW%Q$anEkeC5*{B;AaO&R$-n=|_Ue)Q z13Jnn3v<(yryEly_cuF<e=EEyOm0wGi{?L;`K}A zF%|#Fo2J(Lj24OdP$M3;RP?&QsUt*o2V$Kt!XNeQq^l)sZpjlxF(n6t=KQDI0Ew+6 z4LwP~*ch~z{2F_*#rYGl9tZMdGUbp)$JgNZwMcPMN*wZ@&mm=M$-8x<2R^*Wo`kDt z@N6DySP|v5>S$P=DrnD=4UM(}X*R=+XjPlF^z(W7}>Ne<}}NBS-{(IbIh zpm&(~*@S~|tdMPcokrPzMJ2q*X{$M;H3uwjOd_A>4qjhKBJ+r$j}Mx1c4CiZ44uFG z0eI1bewZunE=flz(qlXwO(kH2A4}cUgQ*$L@P$J6w!#rF&BD~F=u+{U8wO%+_KxC} zyf(!|T==^d9QV4@XhXdXV4sWSEHP&@#aw_psAiL^k1x-Wp zpqQa&slh{W?2@VPy=^v4nrDZ=9AMrVE$n4|p*`|J*NjBnG1Deu=p-Gdd!vdaHrWs= zVs$fsq+;>ghv`HhgU7z2RSEEI!!A609n1~C1crr_VMbC4pnsSHt91cyGLVIf2xb1< z8hs#XTp`XKf-Oh9*$AAS90J!a{qjK9TTQBkzh_HcX9_H9G3X)UEKDJ_%&xgJh#vcP zL(Y*`hx|Oh3R#$<-yoYgP1Cwj2!sM-9Vs34-iv+?5%3{brcdal_eZ&!22M2{g7$Dk zF)BG*Zc#U_cV9vv)t*a&JUq@p;wyOFp6%50a!1Q=Vt_8v%K>-Qli>4hPbcm`Ee#JF z*xyXC2#~xzLv$SnbHxWqd+cER-)Y3IWV8t)e$&%tM2+AiXh~)&x;0_(4Luy%Z-os# zl(T-ZqKo?451SDmx#$Y)gADiljx z?8a1pb)COTo0qzuQOzXn-lASX%Mya=m7>rO4J67UD?)60MeNd0=L%@~Jwg)eUeQw3 z2{ex$L}%=QiayW}{jlXFecn1%TSE+WF+mar4-bftzJ*0-%aD)f@XiW4I;rq1a$nlhA}T zR2_$UU?mL@FHu=*Le6{49^cF*GJIqLh4#o(JL2UgEvA^Lv7IPq{JVUpgP-jsr|;R5 z%Lm6Z6Mw~=(qp9URqWC?om+Ag9=f_FQ1$px*xj0jrFY6ANrA@K_2cVd1PwS7!Z%@C zi=?{q(oI~qd&{fq7J^gKC~ZQhzA)Qj~I*7H%|}@e0c% z<>AG3#Ui$K0AuaHd>4?ORrgyIdCFH+NVDJ%gLr#3bYR^8Za}Ixm*n|&{S3Y} zlYpi1iRu(_iyW0nBSXd$Kl9_a>~QHan-~`Jg&;268jj=GY|Y`QuYV6Ri_X71BKM2 zxl6i`xN3pz=YKC`t12_ixV|#Ml$UW@P`35diXkQM%#e!Z^e`fn@%fVzpHD>TY*@iL zPPr^VB>57nSzq5X5Jb>QR`j%U!x?ky@hV1bU{*Atd~rpm#g-|Ia3@;v(p!)_ZWhv& z)?GKq%bA{oGG-vKaRi?gE_kVM@oJHnqH%cvY)=O8c^&sODG5jMtVbj?oHn8>g;=rt zUu~CZG?WV%$KQ9xmClGrx^CQZvPKLQlg1KR%f7D>H)P+JF-&B;-AM~3hKNv1q?C1d zO+rG0%NQC4jpdlK#Go16ocrP4bL#o@d;aG+&xhyy&vVW{kLCOt@KtoV%I`#O*E;JE zk{`Oj<-+PxLKV1b*;psv8?q1~{7{{!=f?3hp^wd~BNFHtNwk7nzqRT4k=qRzmM{2a zX!kfYPCfM^1qb`V6%u#AmI2=aB&>jgjG+F7*3^W>eT<)LO#) z+RgZrZZveB{<@L&p^H;oZ?$olUDjLnf{Y{C8pf-!g4x0B_9(>qC$x17)}l|lKZ5u;g=2dP!f;CfW5U#GTAxzUwWh}04K6tK zkt-=$VPLhFsD3PHGN68eO>gwihteD4B!C^GyVLaYS7Td9O;tEF*)3dLPwP)FBF0d( zG=WXH%L=Ol5c4B=pQmCwvoJR=b+X>GCG|cmcM<*N&~x zOW4wyh-R#f-TnUNiCzsFm0%n)xx1P8Dci|@EED8gRyVxQF?4y2@Y2EgYClH6N4xWe zzxl0qr9*D2_Ou1Ss3}H?A;%gpt3ALIfeSEMJsfKG#&vCB1Uz=2BG^h*kZFD+={5$n zI89oIqZDNA*KN)XPV`<$m)8T@^z#28L}JXvlbt<+lD{uA;}OI|ETspiregH@Vu(^% z6bWNQN1+tCu6$af&@nX};GvRR5>k`u8GYAb2#g$Fmn@3+z1G;HupcW>Jsz85-*1#@ zG2lWgU20&D=IZhz)yD%e){O?~bY?=% zs%ge+8zS*Yw#|wm*R;ZwK&;|;(#Rdk|5YTuZ6j@3hmQ?a>2i zgs+8I^y5;ERy5fVW!HLTAF!ilEMpGn3I00*smv%pFE6}sHgK;uHMF=`t?!xq4}Ox4q5uE@ literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_push_step3.png b/en/chapter_heap/heap.assets/heap_push_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..6cc315552df24ac388bc51e9fc739e913853020d GIT binary patch literal 24734 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 Bn&JQe literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_push_step4.png b/en/chapter_heap/heap.assets/heap_push_step4.png new file mode 100644 index 0000000000000000000000000000000000000000..91aaaf7cccbfa1694a85ac7886332b051cebad1d GIT binary patch literal 26950 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_push_step6.png b/en/chapter_heap/heap.assets/heap_push_step6.png new file mode 100644 index 0000000000000000000000000000000000000000..4430ae49ed163d9883ab20ab7363008c33b594c2 GIT binary patch literal 27387 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 UU0z}Hy8rSIRJ4?<6w%oK1;T{f*#H0l literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_push_step8.png b/en/chapter_heap/heap.assets/heap_push_step8.png new file mode 100644 index 0000000000000000000000000000000000000000..414aeaef134ee63cfff2c882b75e03c8266c3ba2 GIT binary patch literal 27279 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 +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    8.1   Heap

    +

    A "heap" is a complete binary tree that satisfies specific conditions and can be mainly divided into two types, as shown in the Figure 8-1 .

    +
      +
    • "Min heap": The value of any node \(\leq\) the values of its child nodes.
      • +
    • "Max heap": The value of any node \(\geq\) the values of its child nodes.
      • +
    +

    Min heap and max heap

    +

    Figure 8-1   Min heap and max heap

    + +

    As a special case of a complete binary tree, heaps have the following characteristics:

    +
      +
    • The bottom layer nodes are filled from left to right, and nodes in other layers are fully filled.
      • +
    • The root node of the binary tree is called the "heap top," and the bottom-rightmost node is called the "heap bottom."
      • +
    • For max heaps (min heaps), the value of the heap top element (root node) is the largest (smallest).
      • +
    +

    8.1.1   Common operations on heaps

    +

    It should be noted that many programming languages provide a "priority queue," which is an abstract data structure defined as a queue with priority sorting.

    +

    In fact, heaps are often used to implement priority queues, with max heaps equivalent to priority queues where elements are dequeued in descending order. From a usage perspective, we can consider "priority queue" and "heap" as equivalent data structures. Therefore, this book does not make a special distinction between the two, uniformly referring to them as "heap."

    +

    Common operations on heaps are shown in the Table 8-1 , and the method names depend on the programming language.

    +

    Table 8-1   Efficiency of Heap Operations

    + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Method nameDescriptionTime complexity
    push()Add an element to the heap\(O(\log n)\)
    pop()Remove the top element from the heap\(O(\log n)\)
    peek()Access the top element (for max/min heap, the max/min value)\(O(1)\)
    size()Get the number of elements in the heap\(O(1)\)
    isEmpty()Check if the heap is empty\(O(1)\)
    +
    +

    In practice, we can directly use the heap class (or priority queue class) provided by programming languages.

    +

    Similar to sorting algorithms where we have "ascending order" and "descending order," we can switch between "min heap" and "max heap" by setting a flag or modifying the Comparator. The code is as follows:

    +
    +
    +
    +
    heap.py
    # 初始化小顶堆
+min_heap, flag = [], 1
+# 初始化大顶堆
+max_heap, flag = [], -1
+
+# Python 的 heapq 模块默认实现小顶堆
+# 考虑将“元素取负”后再入堆，这样就可以将大小关系颠倒，从而实现大顶堆
+# 在本示例中，flag = 1 时对应小顶堆，flag = -1 时对应大顶堆
+
+# 元素入堆
+heapq.heappush(max_heap, flag * 1)
+heapq.heappush(max_heap, flag * 3)
+heapq.heappush(max_heap, flag * 2)
+heapq.heappush(max_heap, flag * 5)
+heapq.heappush(max_heap, flag * 4)
+
+# 获取堆顶元素
+peek: int = flag * max_heap[0] # 5
+
+# 堆顶元素出堆
+# 出堆元素会形成一个从大到小的序列
+val = flag * heapq.heappop(max_heap) # 5
+val = flag * heapq.heappop(max_heap) # 4
+val = flag * heapq.heappop(max_heap) # 3
+val = flag * heapq.heappop(max_heap) # 2
+val = flag * heapq.heappop(max_heap) # 1
+
+# 获取堆大小
+size: int = len(max_heap)
+
+# 判断堆是否为空
+is_empty: bool = not max_heap
+
+# 输入列表并建堆
+min_heap: list[int] = [1, 3, 2, 5, 4]
+heapq.heapify(min_heap)
+
    +
    +
    +
    heap.cpp
    /* 初始化堆 */
+// 初始化小顶堆
+priority_queue<int, vector<int>, greater<int>> minHeap;
+// 初始化大顶堆
+priority_queue<int, vector<int>, less<int>> maxHeap;
+
+/* 元素入堆 */
+maxHeap.push(1);
+maxHeap.push(3);
+maxHeap.push(2);
+maxHeap.push(5);
+maxHeap.push(4);
+
+/* 获取堆顶元素 */
+int peek = maxHeap.top(); // 5
+
+/* 堆顶元素出堆 */
+// 出堆元素会形成一个从大到小的序列
+maxHeap.pop(); // 5
+maxHeap.pop(); // 4
+maxHeap.pop(); // 3
+maxHeap.pop(); // 2
+maxHeap.pop(); // 1
+
+/* 获取堆大小 */
+int size = maxHeap.size();
+
+/* 判断堆是否为空 */
+bool isEmpty = maxHeap.empty();
+
+/* 输入列表并建堆 */
+vector<int> input{1, 3, 2, 5, 4};
+priority_queue<int, vector<int>, greater<int>> minHeap(input.begin(), input.end());
+
    +
    +
    +
    heap.java
    /* 初始化堆 */
+// 初始化小顶堆
+Queue<Integer> minHeap = new PriorityQueue<>();
+// 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）
+Queue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
+
+/* 元素入堆 */
+maxHeap.offer(1);
+maxHeap.offer(3);
+maxHeap.offer(2);
+maxHeap.offer(5);
+maxHeap.offer(4);
+
+/* 获取堆顶元素 */
+int peek = maxHeap.peek(); // 5
+
+/* 堆顶元素出堆 */
+// 出堆元素会形成一个从大到小的序列
+peek = maxHeap.poll(); // 5
+peek = maxHeap.poll(); // 4
+peek = maxHeap.poll(); // 3
+peek = maxHeap.poll(); // 2
+peek = maxHeap.poll(); // 1
+
+/* 获取堆大小 */
+int size = maxHeap.size();
+
+/* 判断堆是否为空 */
+boolean isEmpty = maxHeap.isEmpty();
+
+/* 输入列表并建堆 */
+minHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));
+
    +
    +
    +
    heap.cs
    /* 初始化堆 */
+// 初始化小顶堆
+PriorityQueue<int, int> minHeap = new();
+// 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）
+PriorityQueue<int, int> maxHeap = new(Comparer<int>.Create((x, y) => y - x));
+
+/* 元素入堆 */
+maxHeap.Enqueue(1, 1);
+maxHeap.Enqueue(3, 3);
+maxHeap.Enqueue(2, 2);
+maxHeap.Enqueue(5, 5);
+maxHeap.Enqueue(4, 4);
+
+/* 获取堆顶元素 */
+int peek = maxHeap.Peek();//5
+
+/* 堆顶元素出堆 */
+// 出堆元素会形成一个从大到小的序列
+peek = maxHeap.Dequeue();  // 5
+peek = maxHeap.Dequeue();  // 4
+peek = maxHeap.Dequeue();  // 3
+peek = maxHeap.Dequeue();  // 2
+peek = maxHeap.Dequeue();  // 1
+
+/* 获取堆大小 */
+int size = maxHeap.Count;
+
+/* 判断堆是否为空 */
+bool isEmpty = maxHeap.Count == 0;
+
+/* 输入列表并建堆 */
+minHeap = new PriorityQueue<int, int>([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);
+
    +
    +
    +
    heap.go
    // Go 语言中可以通过实现 heap.Interface 来构建整数大顶堆
+// 实现 heap.Interface 需要同时实现 sort.Interface
+type intHeap []any
+
+// Push heap.Interface 的方法，实现推入元素到堆
+func (h *intHeap) Push(x any) {
+    // Push 和 Pop 使用 pointer receiver 作为参数
+    // 因为它们不仅会对切片的内容进行调整，还会修改切片的长度。
+    *h = append(*h, x.(int))
+}
+
+// Pop heap.Interface 的方法，实现弹出堆顶元素
+func (h *intHeap) Pop() any {
+    // 待出堆元素存放在最后
+    last := (*h)[len(*h)-1]
+    *h = (*h)[:len(*h)-1]
+    return last
+}
+
+// Len sort.Interface 的方法
+func (h *intHeap) Len() int {
+    return len(*h)
+}
+
+// Less sort.Interface 的方法
+func (h *intHeap) Less(i, j int) bool {
+    // 如果实现小顶堆，则需要调整为小于号
+    return (*h)[i].(int) > (*h)[j].(int)
+}
+
+// Swap sort.Interface 的方法
+func (h *intHeap) Swap(i, j int) {
+    (*h)[i], (*h)[j] = (*h)[j], (*h)[i]
+}
+
+// Top 获取堆顶元素
+func (h *intHeap) Top() any {
+    return (*h)[0]
+}
+
+/* Driver Code */
+func TestHeap(t *testing.T) {
+    /* 初始化堆 */
+    // 初始化大顶堆
+    maxHeap := &intHeap{}
+    heap.Init(maxHeap)
+    /* 元素入堆 */
+    // 调用 heap.Interface 的方法，来添加元素
+    heap.Push(maxHeap, 1)
+    heap.Push(maxHeap, 3)
+    heap.Push(maxHeap, 2)
+    heap.Push(maxHeap, 4)
+    heap.Push(maxHeap, 5)
+
+    /* 获取堆顶元素 */
+    top := maxHeap.Top()
+    fmt.Printf("堆顶元素为 %d\n", top)
+
+    /* 堆顶元素出堆 */
+    // 调用 heap.Interface 的方法，来移除元素
+    heap.Pop(maxHeap) // 5
+    heap.Pop(maxHeap) // 4
+    heap.Pop(maxHeap) // 3
+    heap.Pop(maxHeap) // 2
+    heap.Pop(maxHeap) // 1
+
+    /* 获取堆大小 */
+    size := len(*maxHeap)
+    fmt.Printf("堆元素数量为 %d\n", size)
+
+    /* 判断堆是否为空 */
+    isEmpty := len(*maxHeap) == 0
+    fmt.Printf("堆是否为空 %t\n", isEmpty)
+}
+
    +
    +
    +
    heap.swift
    /* 初始化堆 */
+// Swift 的 Heap 类型同时支持最大堆和最小堆，且需要引入 swift-collections
+var heap = Heap<Int>()
+
+/* 元素入堆 */
+heap.insert(1)
+heap.insert(3)
+heap.insert(2)
+heap.insert(5)
+heap.insert(4)
+
+/* 获取堆顶元素 */
+var peek = heap.max()!
+
+/* 堆顶元素出堆 */
+peek = heap.removeMax() // 5
+peek = heap.removeMax() // 4
+peek = heap.removeMax() // 3
+peek = heap.removeMax() // 2
+peek = heap.removeMax() // 1
+
+/* 获取堆大小 */
+let size = heap.count
+
+/* 判断堆是否为空 */
+let isEmpty = heap.isEmpty
+
+/* 输入列表并建堆 */
+let heap2 = Heap([1, 3, 2, 5, 4])
+
    +
    +
    +
    heap.js
    // JavaScript 未提供内置 Heap 类
+
    +
    +
    +
    heap.ts
    // TypeScript 未提供内置 Heap 类
+
    +
    +
    +
    heap.dart
    // Dart 未提供内置 Heap 类
+
    +
    +
    +
    heap.rs
    use std::collections::BinaryHeap;
+use std::cmp::Reverse;
+
+/* 初始化堆 */
+// 初始化小顶堆
+let mut min_heap = BinaryHeap::<Reverse<i32>>::new();
+// 初始化大顶堆
+let mut max_heap = BinaryHeap::new();
+
+/* 元素入堆 */
+max_heap.push(1);
+max_heap.push(3);
+max_heap.push(2);
+max_heap.push(5);
+max_heap.push(4);
+
+/* 获取堆顶元素 */
+let peek = max_heap.peek().unwrap();  // 5
+
+/* 堆顶元素出堆 */
+// 出堆元素会形成一个从大到小的序列
+let peek = max_heap.pop().unwrap();   // 5
+let peek = max_heap.pop().unwrap();   // 4
+let peek = max_heap.pop().unwrap();   // 3
+let peek = max_heap.pop().unwrap();   // 2
+let peek = max_heap.pop().unwrap();   // 1
+
+/* 获取堆大小 */
+let size = max_heap.len();
+
+/* 判断堆是否为空 */
+let is_empty = max_heap.is_empty();
+
+/* 输入列表并建堆 */
+let min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);
+
    +
    +
    +
    heap.c
    // C 未提供内置 Heap 类
+
    +
    +
    +
    heap.kt
    /* 初始化堆 */
+// 初始化小顶堆
+var minHeap = PriorityQueue<Int>()
+// 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）
+val maxHeap = PriorityQueue { a: Int, b: Int -> b - a }
+
+/* 元素入堆 */
+maxHeap.offer(1)
+maxHeap.offer(3)
+maxHeap.offer(2)
+maxHeap.offer(5)
+maxHeap.offer(4)
+
+/* 获取堆顶元素 */
+var peek = maxHeap.peek() // 5
+
+/* 堆顶元素出堆 */
+// 出堆元素会形成一个从大到小的序列
+peek = maxHeap.poll() // 5
+peek = maxHeap.poll() // 4
+peek = maxHeap.poll() // 3
+peek = maxHeap.poll() // 2
+peek = maxHeap.poll() // 1
+
+/* 获取堆大小 */
+val size = maxHeap.size
+
+/* 判断堆是否为空 */
+val isEmpty = maxHeap.isEmpty()
+
+/* 输入列表并建堆 */
+minHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))
+
    +
    +
    +
    heap.rb
    
+
    +
    +
    +
    heap.zig
    
+
    +
    +
    +
    +
    +可视化运行 +

    https://pythontutor.com/render.html#code=import%20heapq%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20min_heap,%20flag%20%3D%20%5B%5D,%201%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20max_heap,%20flag%20%3D%20%5B%5D,%20-1%0A%20%20%20%20%0A%20%20%20%20%23%20Python%20%E7%9A%84%20heapq%20%E6%A8%A1%E5%9D%97%E9%BB%98%E8%AE%A4%E5%AE%9E%E7%8E%B0%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E8%80%83%E8%99%91%E5%B0%86%E2%80%9C%E5%85%83%E7%B4%A0%E5%8F%96%E8%B4%9F%E2%80%9D%E5%90%8E%E5%86%8D%E5%85%A5%E5%A0%86%EF%BC%8C%E8%BF%99%E6%A0%B7%E5%B0%B1%E5%8F%AF%E4%BB%A5%E5%B0%86%E5%A4%A7%E5%B0%8F%E5%85%B3%E7%B3%BB%E9%A2%A0%E5%80%92%EF%BC%8C%E4%BB%8E%E8%80%8C%E5%AE%9E%E7%8E%B0%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E5%9C%A8%E6%9C%AC%E7%A4%BA%E4%BE%8B%E4%B8%AD%EF%BC%8Cflag%20%3D%201%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%B0%8F%E9%A1%B6%E5%A0%86%EF%BC%8Cflag%20%3D%20-1%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%201%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%203%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%202%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%205%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%204%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20flag%20*%20max_heap%5B0%5D%20%23%205%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%E5%87%BA%E5%A0%86%0A%20%20%20%20%23%20%E5%87%BA%E5%A0%86%E5%85%83%E7%B4%A0%E4%BC%9A%E5%BD%A2%E6%88%90%E4%B8%80%E4%B8%AA%E4%BB%8E%E5%A4%A7%E5%88%B0%E5%B0%8F%E7%9A%84%E5%BA%8F%E5%88%97%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%205%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%204%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%203%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%202%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%201%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E5%A4%A7%E5%B0%8F%0A%20%20%20%20size%20%3D%20len%28max_heap%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%A0%86%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20not%20max_heap%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%BE%93%E5%85%A5%E5%88%97%E8%A1%A8%E5%B9%B6%E5%BB%BA%E5%A0%86%0A%20%20%20%20min_heap%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20heapq.heapify%28min_heap%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false

    +
    +

    8.1.2   Implementation of heaps

    +

    The following implementation is of a max heap. To convert it into a min heap, simply invert all size logic comparisons (for example, replace \(\geq\) with \(\leq\)). Interested readers are encouraged to implement it on their own.

    +

    1.   Storage and representation of heaps

    +

    As mentioned in the "Binary Trees" section, complete binary trees are well-suited for array representation. Since heaps are a type of complete binary tree, we will use arrays to store heaps.

    +

    When using an array to represent a binary tree, elements represent node values, and indexes represent node positions in the binary tree. Node pointers are implemented through an index mapping formula.

    +

    As shown in the Figure 8-2 , given an index \(i\), the index of its left child is \(2i + 1\), the index of its right child is \(2i + 2\), and the index of its parent is \((i - 1) / 2\) (floor division). When the index is out of bounds, it signifies a null node or the node does not exist.

    +

    Representation and storage of heaps

    +

    Figure 8-2   Representation and storage of heaps

    + +

    We can encapsulate the index mapping formula into functions for convenient later use:

    +
    +
    +
    +
    my_heap.py
    def left(self, i: int) -> int:
+    """获取左子节点的索引"""
+    return 2 * i + 1
+
+def right(self, i: int) -> int:
+    """获取右子节点的索引"""
+    return 2 * i + 2
+
+def parent(self, i: int) -> int:
+    """获取父节点的索引"""
+    return (i - 1) // 2  # 向下整除
+
    +
    +
    +
    my_heap.cpp
    /* 获取左子节点的索引 */
+int left(int i) {
+    return 2 * i + 1;
+}
+
+/* 获取右子节点的索引 */
+int right(int i) {
+    return 2 * i + 2;
+}
+
+/* 获取父节点的索引 */
+int parent(int i) {
+    return (i - 1) / 2; // 向下整除
+}
+
    +
    +
    +
    my_heap.java
    /* 获取左子节点的索引 */
+int left(int i) {
+    return 2 * i + 1;
+}
+
+/* 获取右子节点的索引 */
+int right(int i) {
+    return 2 * i + 2;
+}
+
+/* 获取父节点的索引 */
+int parent(int i) {
+    return (i - 1) / 2; // 向下整除
+}
+
    +
    +
    +
    my_heap.cs
    /* 获取左子节点的索引 */
+int Left(int i) {
+    return 2 * i + 1;
+}
+
+/* 获取右子节点的索引 */
+int Right(int i) {
+    return 2 * i + 2;
+}
+
+/* 获取父节点的索引 */
+int Parent(int i) {
+    return (i - 1) / 2; // 向下整除
+}
+
    +
    +
    +
    my_heap.go
    /* 获取左子节点的索引 */
+func (h *maxHeap) left(i int) int {
+    return 2*i + 1
+}
+
+/* 获取右子节点的索引 */
+func (h *maxHeap) right(i int) int {
+    return 2*i + 2
+}
+
+/* 获取父节点的索引 */
+func (h *maxHeap) parent(i int) int {
+    // 向下整除
+    return (i - 1) / 2
+}
+
    +
    +
    +
    my_heap.swift
    /* 获取左子节点的索引 */
+func left(i: Int) -> Int {
+    2 * i + 1
+}
+
+/* 获取右子节点的索引 */
+func right(i: Int) -> Int {
+    2 * i + 2
+}
+
+/* 获取父节点的索引 */
+func parent(i: Int) -> Int {
+    (i - 1) / 2 // 向下整除
+}
+
    +
    +
    +
    my_heap.js
    /* 获取左子节点的索引 */
+#left(i) {
+    return 2 * i + 1;
+}
+
+/* 获取右子节点的索引 */
+#right(i) {
+    return 2 * i + 2;
+}
+
+/* 获取父节点的索引 */
+#parent(i) {
+    return Math.floor((i - 1) / 2); // 向下整除
+}
+
    +
    +
    +
    my_heap.ts
    /* 获取左子节点的索引 */
+left(i: number): number {
+    return 2 * i + 1;
+}
+
+/* 获取右子节点的索引 */
+right(i: number): number {
+    return 2 * i + 2;
+}
+
+/* 获取父节点的索引 */
+parent(i: number): number {
+    return Math.floor((i - 1) / 2); // 向下整除
+}
+
    +
    +
    +
    my_heap.dart
    /* 获取左子节点的索引 */
+int _left(int i) {
+  return 2 * i + 1;
+}
+
+/* 获取右子节点的索引 */
+int _right(int i) {
+  return 2 * i + 2;
+}
+
+/* 获取父节点的索引 */
+int _parent(int i) {
+  return (i - 1) ~/ 2; // 向下整除
+}
+
    +
    +
    +
    my_heap.rs
    /* 获取左子节点的索引 */
+fn left(i: usize) -> usize {
+    2 * i + 1
+}
+
+/* 获取右子节点的索引 */
+fn right(i: usize) -> usize {
+    2 * i + 2
+}
+
+/* 获取父节点的索引 */
+fn parent(i: usize) -> usize {
+    (i - 1) / 2 // 向下整除
+}
+
    +
    +
    +
    my_heap.c
    /* 获取左子节点的索引 */
+int left(MaxHeap *maxHeap, int i) {
+    return 2 * i + 1;
+}
+
+/* 获取右子节点的索引 */
+int right(MaxHeap *maxHeap, int i) {
+    return 2 * i + 2;
+}
+
+/* 获取父节点的索引 */
+int parent(MaxHeap *maxHeap, int i) {
+    return (i - 1) / 2;
+}
+
    +
    +
    +
    my_heap.kt
    /* 获取左子节点的索引 */
+fun left(i: Int): Int {
+    return 2 * i + 1
+}
+
+/* 获取右子节点的索引 */
+fun right(i: Int): Int {
+    return 2 * i + 2
+}
+
+/* 获取父节点的索引 */
+fun parent(i: Int): Int {
+    return (i - 1) / 2 // 向下整除
+}
+
    +
    +
    +
    my_heap.rb
    [class]{MaxHeap}-[func]{left}
+
+[class]{MaxHeap}-[func]{right}
+
+[class]{MaxHeap}-[func]{parent}
+
    +
    +
    +
    my_heap.zig
    // 获取左子节点的索引
+fn left(i: usize) usize {
+    return 2 * i + 1;
+}
+
+// 获取右子节点的索引
+fn right(i: usize) usize {
+    return 2 * i + 2;
+}
+
+// 获取父节点的索引
+fn parent(i: usize) usize {
+    // return (i - 1) / 2; // 向下整除
+    return @divFloor(i - 1, 2);
+}
+
    +
    +
    +
    +

    2.   Accessing the top element of the heap

    +

    The top element of the heap is the root node of the binary tree, which is also the first element of the list:

    +
    +
    +
    +
    my_heap.py
    def peek(self) -> int:
+    """访问堆顶元素"""
+    return self.max_heap[0]
+
    +
    +
    +
    my_heap.cpp
    /* 访问堆顶元素 */
+int peek() {
+    return maxHeap[0];
+}
+
    +
    +
    +
    my_heap.java
    /* 访问堆顶元素 */
+int peek() {
+    return maxHeap.get(0);
+}
+
    +
    +
    +
    my_heap.cs
    /* 访问堆顶元素 */
+int Peek() {
+    return maxHeap[0];
+}
+
    +
    +
    +
    my_heap.go
    /* 访问堆顶元素 */
+func (h *maxHeap) peek() any {
+    return h.data[0]
+}
+
    +
    +
    +
    my_heap.swift
    /* 访问堆顶元素 */
+func peek() -> Int {
+    maxHeap[0]
+}
+
    +
    +
    +
    my_heap.js
    /* 访问堆顶元素 */
+peek() {
+    return this.#maxHeap[0];
+}
+
    +
    +
    +
    my_heap.ts
    /* 访问堆顶元素 */
+peek(): number {
+    return this.maxHeap[0];
+}
+
    +
    +
    +
    my_heap.dart
    /* 访问堆顶元素 */
+int peek() {
+  return _maxHeap[0];
+}
+
    +
    +
    +
    my_heap.rs
    /* 访问堆顶元素 */
+fn peek(&self) -> Option<i32> {
+    self.max_heap.first().copied()
+}
+
    +
    +
    +
    my_heap.c
    /* 访问堆顶元素 */
+int peek(MaxHeap *maxHeap) {
+    return maxHeap->data[0];
+}
+
    +
    +
    +
    my_heap.kt
    /* 访问堆顶元素 */
+fun peek(): Int {
+    return maxHeap[0]
+}
+
    +
    +
    +
    my_heap.rb
    [class]{MaxHeap}-[func]{peek}
+
    +
    +
    +
    my_heap.zig
    // 访问堆顶元素
+fn peek(self: *Self) T {
+    return self.max_heap.?.items[0];
+}  
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    3.   Inserting an element into the heap

    +

    Given an element val, we first add it to the bottom of the heap. After addition, since val may be larger than other elements in the heap, the heap's integrity might be compromised, thus it's necessary to repair the path from the inserted node to the root node. This operation is called "heapifying".

    +

    Considering starting from the node inserted, perform heapify from bottom to top. As shown in the Figure 8-3 , we compare the value of the inserted node with its parent node, and if the inserted node is larger, we swap them. Then continue this operation, repairing each node in the heap from bottom to top until passing the root node or encountering a node that does not need to be swapped.

    +
    +
    +
    +

    Steps of element insertion into the heap

    +
    +
    +

    heap_push_step2

    +
    +
    +

    heap_push_step3

    +
    +
    +

    heap_push_step4

    +
    +
    +

    heap_push_step5

    +
    +
    +

    heap_push_step6

    +
    +
    +

    heap_push_step7

    +
    +
    +

    heap_push_step8

    +
    +
    +

    heap_push_step9

    +
    +
    +
    +

    Figure 8-3   Steps of element insertion into the heap

    + +

    Given a total of \(n\) nodes, the height of the tree is \(O(\log n)\). Hence, the loop iterations for the heapify operation are at most \(O(\log n)\), making the time complexity of the element insertion operation \(O(\log n)\). The code is as shown:

    +
    +
    +
    +
    my_heap.py
    def push(self, val: int):
+    """元素入堆"""
+    # 添加节点
+    self.max_heap.append(val)
+    # 从底至顶堆化
+    self.sift_up(self.size() - 1)
+
+def sift_up(self, i: int):
+    """从节点 i 开始，从底至顶堆化"""
+    while True:
+        # 获取节点 i 的父节点
+        p = self.parent(i)
+        # 当“越过根节点”或“节点无须修复”时，结束堆化
+        if p < 0 or self.max_heap[i] <= self.max_heap[p]:
+            break
+        # 交换两节点
+        self.swap(i, p)
+        # 循环向上堆化
+        i = p
+
    +
    +
    +
    my_heap.cpp
    /* 元素入堆 */
+void push(int val) {
+    // 添加节点
+    maxHeap.push_back(val);
+    // 从底至顶堆化
+    siftUp(size() - 1);
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+void siftUp(int i) {
+    while (true) {
+        // 获取节点 i 的父节点
+        int p = parent(i);
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if (p < 0 || maxHeap[i] <= maxHeap[p])
+            break;
+        // 交换两节点
+        swap(maxHeap[i], maxHeap[p]);
+        // 循环向上堆化
+        i = p;
+    }
+}
+
    +
    +
    +
    my_heap.java
    /* 元素入堆 */
+void push(int val) {
+    // 添加节点
+    maxHeap.add(val);
+    // 从底至顶堆化
+    siftUp(size() - 1);
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+void siftUp(int i) {
+    while (true) {
+        // 获取节点 i 的父节点
+        int p = parent(i);
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
+            break;
+        // 交换两节点
+        swap(i, p);
+        // 循环向上堆化
+        i = p;
+    }
+}
+
    +
    +
    +
    my_heap.cs
    /* 元素入堆 */
+void Push(int val) {
+    // 添加节点
+    maxHeap.Add(val);
+    // 从底至顶堆化
+    SiftUp(Size() - 1);
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+void SiftUp(int i) {
+    while (true) {
+        // 获取节点 i 的父节点
+        int p = Parent(i);
+        // 若“越过根节点”或“节点无须修复”，则结束堆化
+        if (p < 0 || maxHeap[i] <= maxHeap[p])
+            break;
+        // 交换两节点
+        Swap(i, p);
+        // 循环向上堆化
+        i = p;
+    }
+}
+
    +
    +
    +
    my_heap.go
    /* 元素入堆 */
+func (h *maxHeap) push(val any) {
+    // 添加节点
+    h.data = append(h.data, val)
+    // 从底至顶堆化
+    h.siftUp(len(h.data) - 1)
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+func (h *maxHeap) siftUp(i int) {
+    for true {
+        // 获取节点 i 的父节点
+        p := h.parent(i)
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if p < 0 || h.data[i].(int) <= h.data[p].(int) {
+            break
+        }
+        // 交换两节点
+        h.swap(i, p)
+        // 循环向上堆化
+        i = p
+    }
+}
+
    +
    +
    +
    my_heap.swift
    /* 元素入堆 */
+func push(val: Int) {
+    // 添加节点
+    maxHeap.append(val)
+    // 从底至顶堆化
+    siftUp(i: size() - 1)
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+func siftUp(i: Int) {
+    var i = i
+    while true {
+        // 获取节点 i 的父节点
+        let p = parent(i: i)
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if p < 0 || maxHeap[i] <= maxHeap[p] {
+            break
+        }
+        // 交换两节点
+        swap(i: i, j: p)
+        // 循环向上堆化
+        i = p
+    }
+}
+
    +
    +
    +
    my_heap.js
    /* 元素入堆 */
+push(val) {
+    // 添加节点
+    this.#maxHeap.push(val);
+    // 从底至顶堆化
+    this.#siftUp(this.size() - 1);
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+#siftUp(i) {
+    while (true) {
+        // 获取节点 i 的父节点
+        const p = this.#parent(i);
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;
+        // 交换两节点
+        this.#swap(i, p);
+        // 循环向上堆化
+        i = p;
+    }
+}
+
    +
    +
    +
    my_heap.ts
    /* 元素入堆 */
+push(val: number): void {
+    // 添加节点
+    this.maxHeap.push(val);
+    // 从底至顶堆化
+    this.siftUp(this.size() - 1);
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+siftUp(i: number): void {
+    while (true) {
+        // 获取节点 i 的父节点
+        const p = this.parent(i);
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;
+        // 交换两节点
+        this.swap(i, p);
+        // 循环向上堆化
+        i = p;
+    }
+}
+
    +
    +
    +
    my_heap.dart
    /* 元素入堆 */
+void push(int val) {
+  // 添加节点
+  _maxHeap.add(val);
+  // 从底至顶堆化
+  siftUp(size() - 1);
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+void siftUp(int i) {
+  while (true) {
+    // 获取节点 i 的父节点
+    int p = _parent(i);
+    // 当“越过根节点”或“节点无须修复”时，结束堆化
+    if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {
+      break;
+    }
+    // 交换两节点
+    _swap(i, p);
+    // 循环向上堆化
+    i = p;
+  }
+}
+
    +
    +
    +
    my_heap.rs
    /* 元素入堆 */
+fn push(&mut self, val: i32) {
+    // 添加节点
+    self.max_heap.push(val);
+    // 从底至顶堆化
+    self.sift_up(self.size() - 1);
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+fn sift_up(&mut self, mut i: usize) {
+    loop {
+        // 节点 i 已经是堆顶节点了，结束堆化
+        if i == 0 {
+            break;
+        }
+        // 获取节点 i 的父节点
+        let p = Self::parent(i);
+        // 当“节点无须修复”时，结束堆化
+        if self.max_heap[i] <= self.max_heap[p] {
+            break;
+        }
+        // 交换两节点
+        self.swap(i, p);
+        // 循环向上堆化
+        i = p;
+    }
+}
+
    +
    +
    +
    my_heap.c
    /* 元素入堆 */
+void push(MaxHeap *maxHeap, int val) {
+    // 默认情况下，不应该添加这么多节点
+    if (maxHeap->size == MAX_SIZE) {
+        printf("heap is full!");
+        return;
+    }
+    // 添加节点
+    maxHeap->data[maxHeap->size] = val;
+    maxHeap->size++;
+
+    // 从底至顶堆化
+    siftUp(maxHeap, maxHeap->size - 1);
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+void siftUp(MaxHeap *maxHeap, int i) {
+    while (true) {
+        // 获取节点 i 的父节点
+        int p = parent(maxHeap, i);
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if (p < 0 || maxHeap->data[i] <= maxHeap->data[p]) {
+            break;
+        }
+        // 交换两节点
+        swap(maxHeap, i, p);
+        // 循环向上堆化
+        i = p;
+    }
+}
+
    +
    +
    +
    my_heap.kt
    /* 元素入堆 */
+fun push(value: Int) {
+    // 添加节点
+    maxHeap.add(value)
+    // 从底至顶堆化
+    siftUp(size() - 1)
+}
+
+/* 从节点 i 开始，从底至顶堆化 */
+fun siftUp(it: Int) {
+    // Kotlin的函数参数不可变，因此创建临时变量
+    var i = it
+    while (true) {
+        // 获取节点 i 的父节点
+        val p = parent(i)
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if (p < 0 || maxHeap[i] <= maxHeap[p]) break
+        // 交换两节点
+        swap(i, p)
+        // 循环向上堆化
+        i = p
+    }
+}
+
    +
    +
    +
    my_heap.rb
    [class]{MaxHeap}-[func]{push}
+
+[class]{MaxHeap}-[func]{sift_up}
+
    +
    +
    +
    my_heap.zig
    // 元素入堆
+fn push(self: *Self, val: T) !void {
+    // 添加节点
+    try self.max_heap.?.append(val);
+    // 从底至顶堆化
+    try self.siftUp(self.size() - 1);
+}  
+
+// 从节点 i 开始，从底至顶堆化
+fn siftUp(self: *Self, i_: usize) !void {
+    var i = i_;
+    while (true) {
+        // 获取节点 i 的父节点
+        var p = parent(i);
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
+        if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;
+        // 交换两节点
+        try self.swap(i, p);
+        // 循环向上堆化
+        i = p;
+    }
+}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    4.   Removing the top element from the heap

    +

    The top element of the heap is the root node of the binary tree, that is, the first element of the list. If we directly remove the first element from the list, all node indexes in the binary tree would change, making it difficult to use heapify for repairs subsequently. To minimize changes in element indexes, we use the following steps.

    +
      +
    1. Swap the top element with the bottom element of the heap (swap the root node with the rightmost leaf node).
      2. +
    2. After swapping, remove the bottom of the heap from the list (note, since it has been swapped, what is actually being removed is the original top element).
      3. +
    3. Starting from the root node, perform heapify from top to bottom.
      4. +
    +

    As shown in the Figure 8-4 , the direction of "heapify from top to bottom" is opposite to "heapify from bottom to top". We compare the value of the root node with its two children and swap it with the largest child. Then repeat this operation until passing the leaf node or encountering a node that does not need to be swapped.

    +
    +
    +
    +

    Steps of removing the top element from the heap

    +
    +
    +

    heap_pop_step2

    +
    +
    +

    heap_pop_step3

    +
    +
    +

    heap_pop_step4

    +
    +
    +

    heap_pop_step5

    +
    +
    +

    heap_pop_step6

    +
    +
    +

    heap_pop_step7

    +
    +
    +

    heap_pop_step8

    +
    +
    +

    heap_pop_step9

    +
    +
    +

    heap_pop_step10

    +
    +
    +
    +

    Figure 8-4   Steps of removing the top element from the heap

    + +

    Similar to the element insertion operation, the time complexity of the top element removal operation is also \(O(\log n)\). The code is as follows:

    +
    +
    +
    +
    my_heap.py
    def pop(self) -> int:
+    """元素出堆"""
+    # 判空处理
+    if self.is_empty():
+        raise IndexError("堆为空")
+    # 交换根节点与最右叶节点（交换首元素与尾元素）
+    self.swap(0, self.size() - 1)
+    # 删除节点
+    val = self.max_heap.pop()
+    # 从顶至底堆化
+    self.sift_down(0)
+    # 返回堆顶元素
+    return val
+
+def sift_down(self, i: int):
+    """从节点 i 开始，从顶至底堆化"""
+    while True:
+        # 判断节点 i, l, r 中值最大的节点，记为 ma
+        l, r, ma = self.left(i), self.right(i), i
+        if l < self.size() and self.max_heap[l] > self.max_heap[ma]:
+            ma = l
+        if r < self.size() and self.max_heap[r] > self.max_heap[ma]:
+            ma = r
+        # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if ma == i:
+            break
+        # 交换两节点
+        self.swap(i, ma)
+        # 循环向下堆化
+        i = ma
+
    +
    +
    +
    my_heap.cpp
    /* 元素出堆 */
+void pop() {
+    // 判空处理
+    if (isEmpty()) {
+        throw out_of_range("堆为空");
+    }
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    swap(maxHeap[0], maxHeap[size() - 1]);
+    // 删除节点
+    maxHeap.pop_back();
+    // 从顶至底堆化
+    siftDown(0);
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+void siftDown(int i) {
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        int l = left(i), r = right(i), ma = i;
+        if (l < size() && maxHeap[l] > maxHeap[ma])
+            ma = l;
+        if (r < size() && maxHeap[r] > maxHeap[ma])
+            ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (ma == i)
+            break;
+        swap(maxHeap[i], maxHeap[ma]);
+        // 循环向下堆化
+        i = ma;
+    }
+}
+
    +
    +
    +
    my_heap.java
    /* 元素出堆 */
+int pop() {
+    // 判空处理
+    if (isEmpty())
+        throw new IndexOutOfBoundsException();
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    swap(0, size() - 1);
+    // 删除节点
+    int val = maxHeap.remove(size() - 1);
+    // 从顶至底堆化
+    siftDown(0);
+    // 返回堆顶元素
+    return val;
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+void siftDown(int i) {
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        int l = left(i), r = right(i), ma = i;
+        if (l < size() && maxHeap.get(l) > maxHeap.get(ma))
+            ma = l;
+        if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
+            ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (ma == i)
+            break;
+        // 交换两节点
+        swap(i, ma);
+        // 循环向下堆化
+        i = ma;
+    }
+}
+
    +
    +
    +
    my_heap.cs
    /* 元素出堆 */
+int Pop() {
+    // 判空处理
+    if (IsEmpty())
+        throw new IndexOutOfRangeException();
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    Swap(0, Size() - 1);
+    // 删除节点
+    int val = maxHeap.Last();
+    maxHeap.RemoveAt(Size() - 1);
+    // 从顶至底堆化
+    SiftDown(0);
+    // 返回堆顶元素
+    return val;
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+void SiftDown(int i) {
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        int l = Left(i), r = Right(i), ma = i;
+        if (l < Size() && maxHeap[l] > maxHeap[ma])
+            ma = l;
+        if (r < Size() && maxHeap[r] > maxHeap[ma])
+            ma = r;
+        // 若“节点 i 最大”或“越过叶节点”，则结束堆化
+        if (ma == i) break;
+        // 交换两节点
+        Swap(i, ma);
+        // 循环向下堆化
+        i = ma;
+    }
+}
+
    +
    +
    +
    my_heap.go
    /* 元素出堆 */
+func (h *maxHeap) pop() any {
+    // 判空处理
+    if h.isEmpty() {
+        fmt.Println("error")
+        return nil
+    }
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    h.swap(0, h.size()-1)
+    // 删除节点
+    val := h.data[len(h.data)-1]
+    h.data = h.data[:len(h.data)-1]
+    // 从顶至底堆化
+    h.siftDown(0)
+
+    // 返回堆顶元素
+    return val
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+func (h *maxHeap) siftDown(i int) {
+    for true {
+        // 判断节点 i, l, r 中值最大的节点，记为 max
+        l, r, max := h.left(i), h.right(i), i
+        if l < h.size() && h.data[l].(int) > h.data[max].(int) {
+            max = l
+        }
+        if r < h.size() && h.data[r].(int) > h.data[max].(int) {
+            max = r
+        }
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if max == i {
+            break
+        }
+        // 交换两节点
+        h.swap(i, max)
+        // 循环向下堆化
+        i = max
+    }
+}
+
    +
    +
    +
    my_heap.swift
    /* 元素出堆 */
+func pop() -> Int {
+    // 判空处理
+    if isEmpty() {
+        fatalError("堆为空")
+    }
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    swap(i: 0, j: size() - 1)
+    // 删除节点
+    let val = maxHeap.remove(at: size() - 1)
+    // 从顶至底堆化
+    siftDown(i: 0)
+    // 返回堆顶元素
+    return val
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+func siftDown(i: Int) {
+    var i = i
+    while true {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        let l = left(i: i)
+        let r = right(i: i)
+        var ma = i
+        if l < size(), maxHeap[l] > maxHeap[ma] {
+            ma = l
+        }
+        if r < size(), maxHeap[r] > maxHeap[ma] {
+            ma = r
+        }
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if ma == i {
+            break
+        }
+        // 交换两节点
+        swap(i: i, j: ma)
+        // 循环向下堆化
+        i = ma
+    }
+}
+
    +
    +
    +
    my_heap.js
    /* 元素出堆 */
+pop() {
+    // 判空处理
+    if (this.isEmpty()) throw new Error('堆为空');
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    this.#swap(0, this.size() - 1);
+    // 删除节点
+    const val = this.#maxHeap.pop();
+    // 从顶至底堆化
+    this.#siftDown(0);
+    // 返回堆顶元素
+    return val;
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+#siftDown(i) {
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        const l = this.#left(i),
+            r = this.#right(i);
+        let ma = i;
+        if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;
+        if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (ma === i) break;
+        // 交换两节点
+        this.#swap(i, ma);
+        // 循环向下堆化
+        i = ma;
+    }
+}
+
    +
    +
    +
    my_heap.ts
    /* 元素出堆 */
+pop(): number {
+    // 判空处理
+    if (this.isEmpty()) throw new RangeError('Heap is empty.');
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    this.swap(0, this.size() - 1);
+    // 删除节点
+    const val = this.maxHeap.pop();
+    // 从顶至底堆化
+    this.siftDown(0);
+    // 返回堆顶元素
+    return val;
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+siftDown(i: number): void {
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        const l = this.left(i),
+            r = this.right(i);
+        let ma = i;
+        if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;
+        if (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (ma === i) break;
+        // 交换两节点
+        this.swap(i, ma);
+        // 循环向下堆化
+        i = ma;
+    }
+}
+
    +
    +
    +
    my_heap.dart
    /* 元素出堆 */
+int pop() {
+  // 判空处理
+  if (isEmpty()) throw Exception('堆为空');
+  // 交换根节点与最右叶节点（交换首元素与尾元素）
+  _swap(0, size() - 1);
+  // 删除节点
+  int val = _maxHeap.removeLast();
+  // 从顶至底堆化
+  siftDown(0);
+  // 返回堆顶元素
+  return val;
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+void siftDown(int i) {
+  while (true) {
+    // 判断节点 i, l, r 中值最大的节点，记为 ma
+    int l = _left(i);
+    int r = _right(i);
+    int ma = i;
+    if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;
+    if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;
+    // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+    if (ma == i) break;
+    // 交换两节点
+    _swap(i, ma);
+    // 循环向下堆化
+    i = ma;
+  }
+}
+
    +
    +
    +
    my_heap.rs
    /* 元素出堆 */
+fn pop(&mut self) -> i32 {
+    // 判空处理
+    if self.is_empty() {
+        panic!("index out of bounds");
+    }
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    self.swap(0, self.size() - 1);
+    // 删除节点
+    let val = self.max_heap.remove(self.size() - 1);
+    // 从顶至底堆化
+    self.sift_down(0);
+    // 返回堆顶元素
+    val
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+fn sift_down(&mut self, mut i: usize) {
+    loop {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);
+        if l < self.size() && self.max_heap[l] > self.max_heap[ma] {
+            ma = l;
+        }
+        if r < self.size() && self.max_heap[r] > self.max_heap[ma] {
+            ma = r;
+        }
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if ma == i {
+            break;
+        }
+        // 交换两节点
+        self.swap(i, ma);
+        // 循环向下堆化
+        i = ma;
+    }
+}
+
    +
    +
    +
    my_heap.c
    /* 元素出堆 */
+int pop(MaxHeap *maxHeap) {
+    // 判空处理
+    if (isEmpty(maxHeap)) {
+        printf("heap is empty!");
+        return INT_MAX;
+    }
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    swap(maxHeap, 0, size(maxHeap) - 1);
+    // 删除节点
+    int val = maxHeap->data[maxHeap->size - 1];
+    maxHeap->size--;
+    // 从顶至底堆化
+    siftDown(maxHeap, 0);
+
+    // 返回堆顶元素
+    return val;
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+void siftDown(MaxHeap *maxHeap, int i) {
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 max
+        int l = left(maxHeap, i);
+        int r = right(maxHeap, i);
+        int max = i;
+        if (l < size(maxHeap) && maxHeap->data[l] > maxHeap->data[max]) {
+            max = l;
+        }
+        if (r < size(maxHeap) && maxHeap->data[r] > maxHeap->data[max]) {
+            max = r;
+        }
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (max == i) {
+            break;
+        }
+        // 交换两节点
+        swap(maxHeap, i, max);
+        // 循环向下堆化
+        i = max;
+    }
+}
+
    +
    +
    +
    my_heap.kt
    /* 元素出堆 */
+fun pop(): Int {
+    // 判空处理
+    if (isEmpty()) throw IndexOutOfBoundsException()
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    swap(0, size() - 1)
+    // 删除节点
+    val value = maxHeap.removeAt(size() - 1)
+    // 从顶至底堆化
+    siftDown(0)
+    // 返回堆顶元素
+    return value
+}
+
+/* 从节点 i 开始，从顶至底堆化 */
+fun siftDown(it: Int) {
+    // Kotlin的函数参数不可变，因此创建临时变量
+    var i = it
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        val l = left(i)
+        val r = right(i)
+        var ma = i
+        if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l
+        if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (ma == i) break
+        // 交换两节点
+        swap(i, ma)
+        // 循环向下堆化
+        i = ma
+    }
+}
+
    +
    +
    +
    my_heap.rb
    [class]{MaxHeap}-[func]{pop}
+
+[class]{MaxHeap}-[func]{sift_down}
+
    +
    +
    +
    my_heap.zig
    // 元素出堆
+fn pop(self: *Self) !T {
+    // 判断处理
+    if (self.isEmpty()) unreachable;
+    // 交换根节点与最右叶节点（交换首元素与尾元素）
+    try self.swap(0, self.size() - 1);
+    // 删除节点
+    var val = self.max_heap.?.pop();
+    // 从顶至底堆化
+    try self.siftDown(0);
+    // 返回堆顶元素
+    return val;
+} 
+
+// 从节点 i 开始，从顶至底堆化
+fn siftDown(self: *Self, i_: usize) !void {
+    var i = i_;
+    while (true) {
+        // 判断节点 i, l, r 中值最大的节点，记为 ma
+        var l = left(i);
+        var r = right(i);
+        var ma = i;
+        if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;
+        if (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r;
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
+        if (ma == i) break;
+        // 交换两节点
+        try self.swap(i, ma);
+        // 循环向下堆化
+        i = ma;
+    }
+}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    8.1.3   Common applications of heaps

    +
      +
    • Priority Queue: Heaps are often the preferred data structure for implementing priority queues, with both enqueue and dequeue operations having a time complexity of \(O(\log n)\), and building a queue having a time complexity of \(O(n)\), all of which are very efficient.
      • +
    • Heap Sort: Given a set of data, we can create a heap from them and then continually perform element removal operations to obtain ordered data. However, we usually use a more elegant method to implement heap sort, as detailed in the "Heap Sort" section.
      • +
    • Finding the Largest \(k\) Elements: This is a classic algorithm problem and also a typical application, such as selecting the top 10 hot news for Weibo hot search, picking the top 10 selling products, etc.
      • +
    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_heap/index.html b/en/chapter_heap/index.html new file mode 100644 index 000000000..c1d21d5d8 --- /dev/null +++ b/en/chapter_heap/index.html @@ -0,0 +1,2273 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Chapter 8.   Heap - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    Chapter 8.   Heap

    +

    Heap

    +
    +

    Abstract

    +

    The heap is like mountain peaks, stacked and undulating, each with its unique shape.

    +

    Among these peaks, the highest one always catches the eye first.

    +
    +

    Chapter Contents

    + + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_heap/summary/index.html b/en/chapter_heap/summary/index.html new file mode 100644 index 000000000..5d7f23556 --- /dev/null +++ b/en/chapter_heap/summary/index.html @@ -0,0 +1,2340 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 8.4 Summary - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    8.4   Summary

    +

    1.   Key review

    +
      +
    • A heap is a complete binary tree, which can be divided into a max heap and a min heap based on its property. The top element of a max (min) heap is the largest (smallest).
      • +
    • A priority queue is defined as a queue with dequeue priority, usually implemented using a heap.
      • +
    • Common operations of a heap and their corresponding time complexities include: element insertion into the heap \(O(\log n)\), removing the top element from the heap \(O(\log n)\), and accessing the top element of the heap \(O(1)\).
      • +
    • A complete binary tree is well-suited to be represented by an array, thus heaps are commonly stored using arrays.
      • +
    • Heapify operations are used to maintain the properties of the heap and are used in both heap insertion and removal operations.
      • +
    • The time complexity of inserting \(n\) elements into a heap and building the heap can be optimized to \(O(n)\), which is highly efficient.
      • +
    • Top-k is a classic algorithm problem that can be efficiently solved using the heap data structure, with a time complexity of \(O(n \log k)\).
      • +
    +

    2.   Q & A

    +

    Q: Is the "heap" in data structures the same concept as the "heap" in memory management?

    +

    The two are not the same concept, even though they are both referred to as "heap". The heap in computer system memory is part of dynamic memory allocation, where the program can use it to store data during execution. The program can request a certain amount of heap memory to store complex structures like objects and arrays. When these data are no longer needed, the program needs to release this memory to prevent memory leaks. Compared to stack memory, the management and usage of heap memory need to be more cautious, as improper use may lead to memory leaks and dangling pointers.

    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_heap/top_k.assets/top_k_heap_step1.png b/en/chapter_heap/top_k.assets/top_k_heap_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..72ba984c780ee42beb2ea7a34ff900b991c8fe17 GIT binary patch literal 13981 zcmb`tXINA{7bu!NGr-V$5h+6zq$(%~3Il?4X^J#)5JjaqNRz$=5vd~5y9lBPh=TMo z3W`dv(u;uf-m7=>zTbK7bAOzB%Jc0XGs()zYDrd-wGv`*S%a2}lL`PptEH)C1OORQ zM73ej$lvxWiCaj;!a(G)Nj78*7@}ijI!%>+9?3>1k+aNJ&YVn3xz{9BFNB z4GRm~+u!^0FMc?j*hIXtkTlbsAtct3rh|U z50{pfA|fK{>+3&%{#;a4l$x5FmzNh97&t#apPQT8+uPgK)z#G0w6(p}-QE5E{rfj> z-t6q`3=R%DIyyf1lrlRzTUlADrKL46FrcQU_Tj^awY9auxj{=y%f-dT_V)Ig{+gko zq0Y|E^z?KXhCSTfZ``;sK0f}a2#$=5{5Je8K0dypqGD=l>Rr=2*LN;vW@ardE#JO< zGflp>va&KfJRB1fqo=30u(0rR^k-;jsEUe8&vf^vPoK<^O%DzZ=GW(6HfG$td)Ls= zF!SZhCsjf3TMNQ!LY0-3FI>2=wYxRFGX1`zz{JGlRYRt`vvbEp2WMbY!ngR9&E?n4 z+0M?+ebar%0vk(8N^ZWiPVd-wUL9rlwxhJWw0XR_y1M$wlP8Wj4mLJ6*$qR*?M2ST zDe^+(F}G|PgHmM0}a9{KKfUfq6FI%N2+Eu*oasJqB8EpA|L@z?K(i8NY&L3iwhhJ za_WXxEV5Er+RtnOAakIlrgG(B|NQ4i$kYRH#=%?mx2U7y|J_G$UmR7t$$`y$LlfaN z%aG!qP+3?QUv3_#Tg_gdBWQgz!H>RWKMyy3y0+_Q;P>T-Q7Yu|SGT(G+tHQro7}Ix zwQ)XCwG2$yz3!OWi=sFOleyofI*|3N#jrp(dcup2+PY7)*uN?Mo$_RLJZGdL<(8oH z_Z2`bzMTBAvLrxDFf)9U1~Q58awDL*jS2wYPD5kPY48mjIuf9nq@h7^G*01`3pbe) zei13LC=MN9{SX~8$%?^9#{mSL3C}<>Mg7yD0&FO8Sb{i&fx?Ag9Q*;p@PCOk7M!ZU zaHKrL#Qh83$)1B!3>G!Wgu@bbU>r#T3iw|FROkCn(beH-E?EZ!P4b@K=12(`-{{iA zJx?lOFwt3Ze0uQW6evs6v5hNA6dcK@&*Yr zfDl0B>& ziZfjHm*w6y%cwZc++=npOiOHTpto|?F{FI5FQvpySSYC38rohQDjmjKC>f|p`ALNCg47KbAlqrP&HhPLo3W0n_cjK=KJ4 zT!1Dm3&}tDrNV*dzkn{ICuDy@3r?Bm{~W(^vK#7uYkA!PN~{pL1+FYY(moijXM>_R zv}TqunETL6UdR~MEkhI)dp>j7M`OpQhLUCVrqV;e<-sq%{!Z>jdiC0I=+!5*46LR= zMx?sH=7Tb=)3+sngUjGVB<*<36qe(f+`kCsI6Q?V-WOWnv9QdzBw&?{arT&cJ!e~ zdOl)zmVB_tqGQ9h++Om6Brq_%Ku<`95Nw)@jUd!f>@L}5)Q2drc^yMXpFy-@e!CSQ z4Xc@xE#DPJ2Ond>@2I98VXsq->M}(JO3{mFBsROlmS+`**h%{M*I!r@Ai)kXc#c7* zaaG?`Nlx{dq$Jy9Uw8eVE~^Mgklz<&dO72QOzvZ{TmDt7PAX|{ic>-80;)p0&MpJ2 zD&hGnqMG4L{*=56aduh@OwQP1hdL{%~S@gifY_M9?fnQAmbn5%A*OU+uZ z`xaxCtWsq()X-rp6pDYKy%W0U!!`QB z*}7wnpIEHKk`C>E8$KvL%lO!t%b)+|L|=rsYkfdc44eI@cRYFKqUNRs^qU51DvVyI zzZzk@??sk-VnwX-);YYIzg|3v3Dp>hd%@j6Uh=MzQNe$Ak1M+4Prp=a)1ob?q8**~ z@z}7j*>zK|*s^ol*|OVNo#jY|*|oeAxxw{4?Yo$^rwWfs9VkZ=H#RzB1yU6E7n=RK zLkoV9%={c6ewdtV-k;u&Y5Qj!IFx(YvaNZUb#nA`0(Nx8o#aC_5XAn`AmVA%BG7bE*nlKCM<`s5ju@JHW*e3+4h5~muKT$|cae3qch z*!wdbP`RDd%&Di#utDQcrm#9>IoL0dxoh#q4W+ZgjQ5qcwS40*Ne5#yAO-l~Gog)l z=|;Hc3z88JnZY-G7E4USRdxzIW_f!CY@%lqjWz?sclC_6X&> zFx6=3*Z_1p&$8VvW=di0Izpa>q@6`=n&Dr-9U2KZGtk>kH)`BHM8;|DX%&nPzRsV$ zAy6254Z3pide#=Sw#R;z%Mu8{JM_@PLjkQ+dz_uA6X&Op(r6*=FqL{#NYr>0}*#AwBx@S+xv|52tLX_ zPd#c4y>q^NnER#skPjv=4ql;Nbs|rx$=5ST+jSWhDvY@gbvf!VbKF_YIpiqsQ^vHx z)?n|t8*SEvI>W+wIZE-#>p(0smpS3A^kt^R8o?07tD;P+=;vX3{)q8*`8AcJykgF{ z=y>av|M3hX86A=t&_29}x{cOQSDkFF-n+qomvIGenKc7`nwe$4oIG=$#zBe~oj~XR za#xh*mGw%dNX&}P+SK$aJ0yE^{nGS-LhPvzUyXH62Ua$f(Ktv*q2DmQNs?22e0ho< zl2sv#@_HnjaoVmm!NOi&E`gV+_h%<~O&Rk=TK8AAD$NNM(FZPD2%;JVF-L4so!dh?>xEiTH*81lgMB65C#wQPh%JWbp8Va z>BfB5zh@zw|D1~CQ#@>e!az=x445(@Ji}-lQ2DO|2*|cx5Gc){-rg=-(2!pm71WXQ zg!|UB5tQh(j^S@ne92UraI=nz%k7J%7zP|{&4`D=6LkQgIM^Tzmhis`Ot~Uz%Lz}4 zr}DvQKG@|ar{*0>!K0$_>8oPuD3NnpCU}%Q14{l?o_Useyra&Dc;m^s##~|Ue>yP# z%-vgx<`jQ$(l(OaDe~a!T1^X#A>uGZRSo(ciBD!DpW8?Bo^Ef-HHFz}Z2A5}Dm~9E zx65wLSMJB}!4YXW#Qki_IvH9v|F8I;S(>D9oG8#ItU3#ohNuzh*XNU7fjaSimEO$u^r0T-&waM? zYUSOnp;fx>&tQDx44Hv3`1_oNM3oKvs#r)5MB%^ARHF?#ka#?5n>Pmm`q2~0mYMlr z9se7~RHF}Uy@zZCStMq9$IX~1AsXh9;~vqPP!|h+VF~0>j8Z{^tNljgga#oghLDnQ zQSIQ&l_@w=-UuM9UY&>A!30nmpjW>Mj<>Cmi|ReUn~qC};GWh9Sh42qSS00rK)n%# z%{{@K?{o+>$bJr!X)&4?Y}`5)Gt^m<5@dFfp6T;LHW?XDfpJpldcu{zP#TPyL0ZZb>bg}K~pI`C0-BeK~1|)9U!fp zULEwy8+rnbHjz_lB+GxLu&(Y=z>L1rlxo8p5JMpi)e57evyXq;H;ayiq}NA3 zVqiT@7Q7ym=Sl`|J$q+a76^u?r1IBpJeBCII8|LOza@VGKDAhcB{6)v1DyEDq;)t? zH9a0ze^f((haE)>h}d6OrhzCIJd8#pf<~?d|~cj4?v`GI|fq{l-YAVRogGUwZMvy zFTZ`Jcm)}#!v2M?FTnTwPjeNMX2}NZ-dK zSx_7m+u4w;XH>|yi}dsVjAX6{Ae}qULtf}Xp2ghQb?y|bmk_2Ocuqjl-NJ|3avd)f z9UeSBsC+kSWTO?}V)*%??xUV23#Z7+zDe&nP_Gm2d_H@gs&k1rO@ z8WK?5Z>K z`)sO=*TAF#MdJ3c&!{cYU2t}uv77+IoQn^@(&yR_p=WI(F>SW#Qjm1`j+Gchm{!EM zG5E0*90S!$#(mq|dk#k{QrX1Hg=cL*$-DW__9Ay=ee3B{u=-eGTC6+`UxnopFTom< zlVk>+OBlnWWn~QfKi*lAr>m1@QKvjp@WaGnS+%<|&LiqVDa$oa)+Md0)Ad(D5H|x{Jttw-#}BYB$}Ky>I{UE8X_a%Fb8y zQqCEZiCFaAE8keBiUN_3!R6`q6z49;EuS~8xp0>=?aif?rGeIq`V=^bixNtCzIpZW zx0`qV#vQrW%Rf}5!#=_sXV%v#6F_7TX!-F)wW8uLcGLhnn%5*Njz6>MKEp(M#DMHc zl3@UaA(|cSQH}gCfGm%;r_qmC93I3UZC7RDsHalyvu&3ifl$=w39~SBmAfEN;G8P& zV>%)x@UKKl4lk8W;LUiZVO_>RT+UUH3pf@Pj%>xql|0~o zpcsDpu+2xZM1_AGU{%H>=)hV%Q)?BbOaw_t*wd{xR0#URM2OnEvGupwlmP*f_pRSD z7RO4*gFpxGj}mN0UCu=wIE(-Jr$l#9X2t6(@=xWINh?pV_54)swlIl+3U{9M)!Xzv zX?uis>d8R1aQuKl(-EQnAs9){+ruFl&!T3yUdgCq0rJmz2w0#QQT+UN>}Ceqa-x#Wy%k~J3`UH5Mz%>hkybmgqAqtf6!26+DBY|JEl$5 zg0!g}-(@_gL+Y{zYb7Ue1XiG2)_Pk?><{Os1}`UA>Q zRbjei=g8D&k&c{@^qOd1@2_Ni`saSvFbY;X{>0 z-5dAD@s9S=io?{5B)Ka5qU<6q|4~^C+P9hVvr2waCm+enLq1t#V`_0pqs}roHQ2G> zwo|V)Nmf-fSu3>cBC9N6rDHyd%WK(SP^GZzB7NP9hZ|WL>|_V6`)BnAdT-gkyApW* zeI0X$-`@E8YrPJu2=sSo|2`4a$-~#i!2|I3I2TEpZnRq-<|6$ir;rwRf_y9$1odaD z)gXQC@gbilhid#u1!xUAM{UA?Qq0SY7X6V+3&k#-6J@AY*qpY;_#L}-z-D2Ak4xckb z-Vghl`CaUsFu!~LCEOjMRa)g%@t)3jDI#~9 zo#JUU=!62obPBm-#_)>r-M6J8KN}|}XCTW3$Uu)7>E6O26C#bdOy56Efwqr(Cqj;~4-`I*bhr6|)m==ZU3 z^U>D}l=RVE*EU%{nDCS_Ykop)$tu7XM38{}YYQfqSoHVbf#@ZAusmfJq}QX;0LpdgOj zH8P`+^)3N_lJ0Kca;^$oRgsH#sOwv0GJjgQaU42-_lv~Sg<}S-x=SDaID_WStPC_O zc?9={ms@YOl{w@v(38=p8u}k$WJSj_e0`5gB&qkIaGj?Njab?OKIybujfi(zubIsq*k=@iKH`dadtP~ z3tTEBeZP}*`D;#CF$;ajY;UzJoE{hS6qtC!CF)n|ISp0G%yV4J-CQ(-Zqqroe|G^x zq}^Aq&h~2zjDnA4zmLW)K>)rYsruUTM;q7^zc*diyPc#)?qqe0v?Nvk=eVA>8yEg< zG%sG;3P=|i=Q2&Iu{9EKww1os2NvdeP zn3N$?gf)mwTK0JYdX&O;7H#S+;Hx-Jaszosh}{(yxyKoGi*<9)PwCm+fS?vK^G_i_ zyP7#Xp9svtktK1HgQOU@(5BDMihEDDm6y&3aLjnQPatJasiKHvl^vxG+&Vf+-T= zLj+TaS|Br6pxSr~tyjG&M<-|qagk!WWnG!!64$+w6?`V_LU=Zv1?~I-O6UGH^OLV9 z;nTS22MZfRvA=v<$Ey4e9u~YOEyV@NxlkBrD6-&R?skz^+_{};%xe4On{M&0iVyjM z7Y?qDG->+mSUTX=dy`Eb7QZA9Tc4uJaE0<%_?Qz-6XnT!o3Y8A=jvGoX$4E(` z`?o;$)^TCbFm1`9T{;YklVx4WA1Z3mQtf2%U@ioI$oY>M{253SacYKXre*q8VCzu; zFUeCXaHm+@CshWvAVxm|JZ?_R*BcV9%CTO2RC&&FDN~E*n4gS{{mD^I#hAe4X4`9R zY(-7bty5nhn!P<}@IL-RmPpQ?EEboq(zwrruN0BJgT?t;vH3Nzk}Sy_sW3z|eSKH_ zgkE(_O-Pz1ZLPV{?Gy4Tw4 zbH5SF)Mam@Vj$)a_ERxDVeB{xERZ;mdsSg;0{w%QLUj*;QA4*9FHS zR#alxzXn1qwV8R26w65(MOQXN_N*9QER!45MEG&{Ci7kN_)<1=p^D*m6Q@}bx8sR= zviEXd{V(^oC&|F28e3FY9EJiVf0=m5d~3(3^roxl_L|4lga-#Md`k1fSB?HW>))-s z!+!H-YGW0Vqb;DU^h%fP!n*M1oS7%jXY6YIBMO-wma1>C_R6@HXY&;q9#xTD!CSp$;TVW27g@S7Q|u(0RU;u2{!%6sR@xVv zVJ)yw!gnh1{7H9UoFiU)eU+YIeiMZp?D;Wm8PUlK!tk6s(ElFu5uNaz#_eIbP3pT> z=r=eRbOwW6j6qj;^yGu`iWHlQPgXi6Pg`ENoz9n5y1TcpYu_02XUFbge=LpSsd)Lb zDgXr_E?#_zUQD>oiM~tW!ERPdE6yWcTJO5GnO5pzrtWx623yQ{3mKYffxWpqLA;8l1AqAa zw2Vw9HwqYT22JM*evrFecZ1*jWHLr7?j8#(gn1~4Sx$VbR?IMkvNbl#4F8lg*4?ap zYr9>C*DM*wdpwTSO6simk^Z@W!r(dUy;*au%*%qWuPQAJw3`dWU26$BBX%W(7M+l3 zIIR6PT{{20e#> zeVZjGuMX^Q`N*mC$vc~07C$d@oMj3vzz48We#(X^zY#Lu@`S6JR4WKGU*!*Lwntt>#*TLYG5o+f*Uzl4fiPEh2n@7iR= z1poz!$qW?90y=4Dz+r11DUu)7?7FG|A8&Sg1__>q-$GXoWU^oGgy3`jY$1K`(g|?y-4XRMf^2dJ2xc9w2*iVku#9WG|0qRuuJmdht7|5 z3-(C3c@79m(KE`2SaF}6EWVozv|o6@XJH7fxxN`rlQEmFLbhJn_VXC!r*ChdlJ7aw zS`QWXkLjv%pMYF@GAy0K;&{+gErPJt^)^q0O>-g#zPmP&tu6O5Gi$CDw}4TI*AbmD-`wYmoC?Yk20wfqT}J|@x}-FwtC!gFSE1@ z#}l%)PfO!UGBBHKUdyAE$f~ZTE<-DRL$sWnAPvE!pxb`xtKALNwNJBV`ojG|o+06Y zMp0=CEqFTE402uAD{rM9WpvH@2uvoknJ5zrF3A0QF~e0J?2@EQym*EG6$dN+m*3O9 z6wqT2a@|?+oh8cJ;z$N>g%+{G998dd-#K*DP~SZ{;y`&l3a!a90CEqjKf)AcXOWuP zUwtGo<-FL5;t>7w02q~97Vv){0j96AaKQn~q6=y|j0^RS={OC}P#68M?lAtm-uaShL(JJ#cUKhED<^CeF}a?(I$%I9@j6UMGlypj_ol~A0?Hy z9|LW2cv3zXUXYKhN24|Cff5^uKKme!Zq%!`7A3oT;HOK4VUN# zJ)y{Xp&_y!SxGFNpvLZE*9;W?g9^#_iZG3X8dshD8S@}jYm2nm%I=z3_sJ$Et+Q;K z6PK(BKdN_!oIEb`)B~ntO&OqOUH`e&`*V`NpjIvG5oNT|0|AO&{)XgV+7H6WG9*j6 zr$3juh>7iVYFWzUr>%i~ zpF;^V8BvLy6UA|9Drg3BMe@-u$Jp@BcSe-U>myDU(5hvjuXshcnbF_J$QXj`gELWN zM5Z*JupXV^F)Uj1mSiVNWHE17?gDIIiY|j5Hh9mjI{|&?c!|y<-zFmo|8A-9H`o8fgSF6Kw^4+Th|yFXWiQb@HN%(Z!{|q1G)HPKZ8+)QvB3d-)b3Z zpJh>|K}jomam0W5+uTI(tpCQ)859HkkJssc=A1NOW#rwv4g!CO69s4poShDu3hY{t z$P~ZDkr0TJEGwE%cSz?IQe2Ky({7`4A+Z}qhe$^0{Jh1sJq9kD0wtZNFK}vqPRk(5 z75bl+`{{=v#&F-3dwxC8HpCtC(7ST8X9RLJ|EWR-m!ht8Wk@#_a~YbmC(lf{0lB0h z9>j3c7ttb%^SdV+5=3&Cd0$SbIp<>gb{QYaa;iTg^*d3`_V=+PTgUIuVj(7E22nl? z_~ZBxWV{pJLi=?ELwRp#gRHrxZm+V)g;0kaqqwbV=XMjfA)rf<7cz>YqH|{lr}lPLf1Ba8PlG)LrWqFPw=b z4Jw$OZ9DepQ;6P4{HNq<=#MAEVRp|2kk+~fL=`8#mk~b0Mp_4N7k;m} zGS#~pioJ$pm5TougLKuK8vyo@rS?IO#$ybyj#?nrnOWPxa9ZGMh0t!=J2HdC%V^CF zF>}=ND_BmBP$DPXc(oz=72uR1yod)>FU2Tv$(F5AtJQ#XmkuXlM4fnvu8_N-55<~; z*QQH+JEr?tsbs`a47=KME$3k>S(Icq8Db4rAxJRvEWw^P*7d|`8eY<$KEvx_QoI+q zTtbF!<}i7aUvDC1K9==7v9~%YuelTFDo#Z$u8gFv4=ad%RgO ziMq`;)1Rnt8!^_j4(dD2u1!a_|E+_K`i}F1`Y4gd$Tt3$kurmUi6p0kR58nPif*{0 z$5goQBVJL|ng2V_r~W?=tQZvCbTN1=2Jdh~8gi zFZ@R8QJK;iW=~lL>z}Bp^5Ud^xx9a+X%X!#Vym#`&+uNub&lJ=tPvCBwm z!ibF&x#%|eQO&sE%128)3Y#ScbIMxOX5J7f(_cCGeTe4%A%Z|p!bvixeB@9!^5z#| z41?xX;BiWfZSZbr=1<#uO@au9D9pN${@~Tgr|o<&=wQN+T%`|FUlfgx4;~3GZ!$gQed|B_IS(FdI2{5|eYB&hBc{lWz=#EZZSp92 zlJ;T-{INt*0t_S?ewY+SCjDL+v&@3XQ1TSAEC?8g6+t~jp|FA$^`PfMtNl}jYoNBr zE}atT8;Q)3baP(rDOyMnCVggI$9QnUQv#h&_(qw*{~ws$XB{taHM|=1&;`C-0Ub5*F+r1gar(P1d zcfNQqlP_CvH1i-z;f+$=Ss#{BkCO5N=QjE`ms2BdI1Vo*FE`hL9yOkY0I{=<=X3InSzvq4T)ezpqWmPC;3ANo{>?oeAxDvh~`@XJ&?(<$>y~Phn zcxy9OBZQe0>4Ha4mxJSLMUCzirnGpCNptDO&xt+X-&;B4*L;7LJ7zn68<{tS*H)MM zzyo~-b?`_{0Pz(lECVw0VPH#(*ov35^Po_Y5r5Pe#*B9g=V3&k5)dSQw}Jgq-m zfz(EX5`>A$1iSs8D2^u7RF*iLYH5}=o!cmKV64t4I;9Y;h48u#zLt{tC_D=L8u-q~ zFxFE2Xp-NfB9t|<4!(H|P?~yRfy&hNl_-nj-;cYj$Y2?f*nZ&KWaZla&v-R|6rBHDF@lJ)V^M^Fy$JuRrZ&RWKIpTX|1UAoRDiQq*5YIho@j zm!5{OeCUM)wB9%ts~ZH6y)46Kmx=W92hH!g4Nkt;j65~*^?BUcpAl>OXC*J$?hqGK zjs;6-p8bG^0^ne{uO47A(4En6ei*L9CTKC9AmFeZP*DiPU`oI=;mGj>fk;zKEjV{n zs^{zV<~u<1jJiaLk3qP?bBtu`=JnS|B!QHGqQEt&LbIQzFkag8%CMesq)Xv5mP;BC zd_ogBP%9JcV`L4g*cZq|saz)Ldxb?qA1vcpLUy5}%?p5Di6F0`^X+zIpzy-RrS~WF zCyui)kT#1~SG8(*0Li_Wb5-XR1He}d@qla|0URuG%JT_8nc8fjMW_J|ncM({1<2ba zEDkW>0peuw0D=LEG(t}7??T?b0I8UJ`G52(ZA(VV{Bov@ITbFTuq5#Y*bDgb&&D*h(sjpO-oEWx--ncCvSB?ML%!7?@vBTl?x$E`zrxTl8#ZGdkTk*0hYOfCkJujfUOcDIjNY8Za?fg1@OvErv3?8dafJMH&lu9c21t3ys(+AZbh@+a*k2**g^eVm(AY4jEu zR|9vW{Qx26MoVx#v1~WuCHkR_@;_i@KjtjwQ&rEkQ^<))v^Ex59YC_+?TFMeCl17< zv3w2RS{;&jdA>5vuRtpLr{0+>-L3qdPWzj04bG0s!mNCjJ~ZS&l0uZKdr?PpZ=oS@ zv&O%5OCm*kvcFn?Yow(+pTem8;6vr^VEpG&F#I%d%E;Pq)cXCeO3BzcJ7l_zc4dj& zYDCv)rd)_;AAV=CQKNg^UJ&YXa!`9z(>08|1R&ZOu^b=zJ|WRky=MQ`B96{{M2Tk9 z@<@Cyqka6wWOrEEhWYO=g46!hb1NnyQ(FbTv=gc8>3lxER`X9)?`QRB{KIGaWk|W* zrA`fg`!$8gia)BB^2fin=NdIuQTr@j8kg}AWdfGuM*GNX$!!yPP=-WW!S;RR?6RDk z`@Y2WZn1g(W1iL3#_XdNa-Z`-FkQqq=-Nh9{0+$Fl*sU&x&H+N9I<^`#tN$0&6!qt(>XXE$87R}1j?)(j_ z9~CX+Ruc~lr0i`O$n>k%&!_EPOu58xRhtvfcSNJ$%Rrl(hg->mI%#ISd;0eCBonTx z-?m65|2kmzq94 z!}m;&D()6yMWSrW!$tYE+m_N3X!+mOIb@LK2aQ{W>Q6q&y%M8yk^W9j{Jv-ww9xb* zH`pmD zqjkQ2xYSuH-{E1SQIq(ieHONIk)Ab;)KH^d>}fWjzsZn#ZU41~=!^WZ7z*a<@twdj zd*w`5vl{^>T*}_uS355@P!hZ)waFojJYS%v(d`0O8a0be_C3(^0&uE*y4G}lRr45a zLPV2vc!Et}u~~edXLCeTOP}kG9Vz07PSuCj`Pnr=DE!*`1TQ^K0|SI6JNP4c|+7ckj#l^#_|w)*mzJxr6$cCp#_z=#bf_wy4+Kp>w9#EQXQ?p!Vf* z?M>o%QVqJq^iWf4R>@%0|AR$}qphpCp`cFY&{@iVcaHy)-%%ZJqUKQt-1J}j8wvmE aYKpP%Wt=IEPJMI)&{DswR-j4<_;}0ZAfAMluMJR*@h< zk_1VvsN|e8w>;1Py{~ug-F-Pe3_aCVzpCn~>F%kn4bi`*O-;d00RW)Z)zL5nfP~mY z^q`T%e><7t_lP&r`d5rJkB^V{_V$842LAo~cV}lOBqU^QZ4H|>-`Ln_{MtxaS$T77 zGqq>qRA5KLNPT+8o8P~Gx3#r(cX!Xv&!?oM^!4>+biV!k`LlEFGJXvI>({T?*x2ms z?C;;d|M>A^aB#5W&(`7L;pph-!omV!i7+-dwtukS-rgP>8mbucVtjmjV`C#OF7CsJ z55>jB(NR%Po;Y(&!0a(J3HId)C89Y zOixc2bQZLd==;;h{-m?GzbLCKE3qXZ`g7FXw^kP~Ui>lp z!`0Q5?MX+=X!D1Gs>gnQl|xIZUsGc0qgS?8t*xyS@bT|j#=3rY_0H}+tqQhGvxxih z(ka);rEWz$qFXm9#@pL_VsZTAa82r$)caZXzZd>2Z7lhJn0Q|Q>~V=-*F@)|_nuXQ z{mOBDZ#!CjioNyI24cQU_x}AoLip|aekin|`sduwimsp0btBHjxlP{*X`jcEKaJkb z8!hbV%K6s*EcMx~q~_}av*Z9Mxa(@1H}V=;_!LMCC;+D)=CR}l%2f`%0< zIwO}VLL&9KWV?E!h1u3w(+AOc+d(^Vd=CEwJF#4}^cDJ8K)Q17QTKo`3t8@58aw*7 z+jd_=(?dP-VA?g73y3?7No$XUNP@fWTW~%Q#yEU`>{_w}IT-Fes;+{5y;*nW%)t$3 zPBpJislwA&$p|b$L-0x~2`=3l@tKtrC%{PO&j!D}f~CWo31C#dF|Iu5gjnIXDS_v~ z-Ca%;_n<#wom~PV-jQRdoH3}xIAKSi5v-TNKOJbC7=(ht`C$xPilReF#e<;# zL#Bfg+g3RSgf!4>X2O~NI=ZF8ELW{8E;U>DlM-w9qOpV?Uq#eVB2LujaH4(m#Fqa( zlJ}{Y*LUw}X*d=z5@mE>DISFm#|sc`mKAB0kj=jzkpF^J^0J^l5moR@fxp2q*`&F0 zAkj^QgvJri%?D&&-0xGcM8$rwwnzDEO%zgA>f?iaM1bwN)J9I8FZ*X)y3{`t1$NFJ zO}UO*2)Oi0n-S5LQydFi&%}$T6Ng1@%em3t8X}=Xt=#O|SoX7RRy`qGDv!kfHsB^1 zGdTkvl(=iF+F!iG+UotAyZ?)Z92xuD`wtnCZl0yTB5NQO8mv%$t=v2FYaPzLc5T9X z>B&OJ(tF&qOQLrr%3G%sfa%zg`-Jd-FW@x!vIAsrY zs#4-zBM5kgYScXtLPecUqELi1%b4n^46nFKptsE<=9MGQl2_wySr^UKco&{Vvs}1!Wsf3CBEpgKj*z8NZ~7)G4*Wt zy5ZO1zQ8O%4bsat3{!8=ASsD1DL8Q;5Q=+DrW*PIIRkMtq4clL?`q!zo03$RUdAm2 zgwT)807mQpc{+Xa33Cj@#FKk28I0MKpVI*Szf?K^gFzp{OaE*5F1~7h2_ail+X`f0 zjmNBP*h)fc1ilu#lm@m`QIWLi47%UTF+>mpNJTmS%)Mq3eRVtO6Vw}!iW{9$Vf|_# zzKRRiUp4JSvcgDsrHCN9VngCWdf)oK(U+)dbbVZx2~FVU!MDOu;xlba0VeA!k?|V4 z^--U>!gPL6B6FEdT=`{rFOo!WgOC{mQhl{6Mt?)2xZQoXzM1TZuJw`;Dv+R-aeEv| z1Q0q8866^a#ISbnK9W~{JpKM$E{iKfHT|QuFCifzEHBRg4bgxNJLJws&-cRD^+$Pg zfK0chF|ak^J;iHD<`wf%ZhVP)5wme6<&~( zg`H>T3rmCHDIPO=i%LosiCVV-3G-@^C5j85j-a69RN0!yDd|#O)bxaGV>fSL-)4gB zBLQ3RowUTaA=!6(uZ`ncO6_e&x7OcU9zhrJO>s5y3Sh5_fgKXlNX3eqBC7xPyzNTK zT$?WD*>UC_E%#H31oU`>-|buETa0#pFM;D5V~^0etIdgM!tn=I)F+v%xrVB)Hnw4S zi~EQ+&-$ON7rOn)f!d%s(XBR>w<`PL(#0-_87T`We9=L^{a|{i7^cTt4TB=m5RW8$ zVknkTs+t7|ZNphj85CRo{OOnA6=!t79YK^0Ql4=^nI*5r@GP zEQhw4-l{o3X-T_t?s^>&xjvJ+DC!jUrE}%TlG*3Jv`NDod_;Ji|MQk>MTwkhf8KU| z`scbN8fV}DW^Y9g>;0~=$TC_lqep1xQ4rK(T8eHr-EPa1qROoBGGJ=yOg-@S*$o5C z8T;pFDwQJc`b?xa^0S%CkbVeE%@T&Y#(5dEMTB{rC?#jfFbqNg?MyWW_UXuPQGB zhz`%$&s&!IZ}UJLEoi3t5As9Hcdkzc{$UssN4MViS6>;)`F|Ph`%AF4%H+EQt2Gt+@_+c^EPE)cyF!u>CNW+;!zW7Mv zV2IBOXwwEpM2e!RFa}?M<-R|~L0QttI!hqXdFB71Kp=IPq+!zrp^rg$z@SN$-u@rf zNbU#!Arb6&6sp?)S(`TyUYp$_O(zkW+b@H<1 zouJ`3Z=MKlc2+X9Q!KE9ig4N5l#Uf2t4PlhWPtHf|A3H?fmbO$-!7m!P_-LQ>VG{={o7d*m%o+QQSeS(x!38s*8hu8f~Tk(QWQ9;_tYODr<1 zZ29y44Q@;tezXO4=!!8ZW)ZCTH7bZIRwTT;aeBUT>|W*En;_XCJt?&uXNZWxNa#_{yqg0|&RzR<} zyxDZo&!wG}G~2s(pfSygfU$Eub4?&#P#u;~h3B10x-1&UT}f9gY3R8ig_1of`0wmp zLK(ZE2cIHbGr!)-hW}dEM7Z+18&8Gv-ec8?+yIvbzWyr|RIhAi!13a@!qIghe!7LL zomqU%)T&IEZqP;5$EgZe{2>WtIg?12S0&W@LjSyVOp$M|_-H(LRdG+w{1vSaJs&&N zlljHJ`MoWj6kC|RXw%Y}J(opTeie5cX#}`&6!?3(G=%cuMq5LtKp{XYO@b@?L%Omf zyuF;|M|MXT(4PC3!nM6z86E|R0@{jX=%M^(G@4M@P=FkNe(7{7b0#ss58fUF+y@^Ec=I!Z~9 zKk5}!L#MSIKe(b-FmUD`Z917KFSK(i5rw;P`V>Cb(F-3dXa3#v0c8}R%me=v-|8ikBDtl|XU5Wsw}KZSF~mz1ay*+?>tpvWC=oQ-E-1nfh_v=bkbl;B67yA zuH3t|MIE>xnCyWZC^Rj-{~*Jz36Ci8{0fRV&CZbELaXGxl!l7ew(tB5!q#MeA`bFs zh&Du*lVmqmB17h4{i&lLa3U=0ZuLFA$lOKSfsa)hYeZ3P^67*IJ7yD>m#q-ijQUVw z?gCWd`{rD)iaSWaMxhB5!wdd4nzz5NBT*V)TtZ5}8yZXo=SZ^(sVm&jd#DCsD)}N@U^xS<4&r(zM|yEl|U_A$W9!>3}PLP)mM!7LLfShOsumg#3xJ$itTDTr*kWDv5S z<9_V)o;M|KYE+5>AD2Z|k`=OrXd|=#E!}7$*$?g5DR9O^o}0Sh8CF)0)CH{&ky{P2 zQN7vt40(1(PTWPvg*u&OZG`BH1XwyaLoU=Ila7$Go`oF75b2vHwMEY#g00dH3^W7D zGQb%E8mTJhD{`qOUFeH$34vu5hfX+52egs^IG5_ne9&lkPozw%;mQwfSeyD&NqBd)u}meoA1J7UDCfYx6QWi4cLi3KyeTy{ zHpe5Bh?2%_3ZQ$-SnBQll)$9ywy6zKLI=X7dOLIoiY?0T)Gtpuwm}n0hoJU)Q=r2h zCTK@05^Cf0a)}BG-~VxyS;=Mj6kv$40`rHhQ1+PbxdVpbFV82Dm>4&({T$Zaw)_h0 z{+xLWMeC@;M=RVr>-{@4tRUn&(yW7v$1y%BHB6e=rwmip{J#4#iw~I|u^k97F%am` zJ%i&|kS#-!VtEh2pqpr$z+M~Ve}eY6A@=_#eJ>KBn1VwM9)r6Jk{6h8fXdjpj4 zK#zl9#|`Hg4mJQqw;|v#8C~pZcU#sB(D@S%gf3bLPs4YQUQsG@-~gWt0w-QRo(n&? zad*-J4|JHy5QNVGl*8O?$8u$#J0YTq*N}@Ou0iedZA*@IS`bnQgsKkDxIBg%cM`IM zk3n=B6&$9-gI=IE|KONj>^PLXGhIeQdFkSG0MHS<`JPi4p-)ik-=vNwTB)n z7?R@nq^9bZx9dH)1V8E9&u!3xSq=Fpi*2vpIvj8lJt68+*dBz5@ECtu#5IeQGCEd3 zZpdvSvF!6Tl&Z>xiMxp}27C&6* z;A=cih8Ru&WotJOLU0#3=CZA^#lI9!l}1v;aN@ri%c-;v>i^1g4m3W-z>mo>ME+7# zbj`ZT@_!^vAtwA3ijH_SL%aYK#MGw-AR(qadEt|MC_VNh4|?UX!{}CS{^28{jyNFW zk(aPcw1f|?qfR%qgBC7<*CQx>fJ9^d-(^lukb-%(76@mpFfW2~u~v-wM>Ts(n@e3! zvghkr)kv;V;!g6iHsnO5|35T}T*tS+N^U>+bAWO=bB1L{Wp4Y^mqT)bmH^F)YthT7 zqPy(S*b5-xveqme0h~0z@z41`Vf(CFK%N(N-f+(I)-E|A|3niE*SSw4s$=Yb`(k(q z!_;Ch2R&ZhE3okF5;gBho5yo$`kbRwMGVu3 zc*X8{MxWt2KC(~q*Cz2{3ubkTXIULeN*9ku?_N14Yd=8!L8_s+Y5R0im12FVcb}Fk zSZ;y-fFpSY*nksX>k1U%V`>^46WNLrCzgf~@C3>Fssc3Rr@kzH$ah^Qt4hJadRFgU zSVc&|0m*w!36H}~K2fbe8wFTQnh2pwnI617OfrhJlc#5`3E z?HOe%Wl0$h5>CEJXHSEXf=@rc{YmE7O7w-&JM3HJStoKF`_0I$x2dk+Mwtuv5NXw> z$C+F4EY9N>SxN2#)}aTLH~RyxYUG6CkX15&vBtrIji<2oC?R$S;f=l~e#x-2#xz1+ zmNdbJj@a68S^`Qd%TT&9DUpFJnxBl!WnM_+Jz}231wC($D*2&(Ti4j;&0e;&41MOh zG8E@%=Y1cc_1eV8ZpXa(nO;sbBcq9g1U${o?8b?W=j6n{&$PDYVy&JhS-D5$5!~|h zoUn(~67%yOnuFlMyPOAFfKt`Yqg0LL`@$Ue_G9**?M8Zwi}dc=*Lyk2hm5Kh=p_83O`0<>7}troEW+PLLGkS@&V` z84d5hDLTzd@1cVj`Ub--A0W^ z)8l8NQnLoNo-p4}bdQtW8(`()<(kmtgZ*fu`I*S1L~cNZ%Gk{3QbV-30I^(AVy*~ZdEXQhPWBK|fkCUe{&=pC2lhp*pQDi;i!CUQ#EdE*<1pXhH=STG( zkm~!~huROs^-SaFqcfLeX<3=wmG{q8Ydkdczzw`8yNlD$iS8h9pgyAQiSwV^!M$aF z%l>Cg3X$6#<=PsO=L`@>A{EbR7MbM2j07vSE?ZD;kyVL`i?+$p)-qK!;x z+;I)DDesZXelzrG=TM+^rR9&}3!tX7N1L@HLPFZ(EpaNr38;7U(OgwM{jH%7fk3dT zU-r9S+Y}w5%=_CnBjD=8Ut-NGGQHh>o81}#IssqJ1;S@R8rQLFFu34_f!&`@sh_Xf zx+19Md$@o5Tp8Pk9K$c8wfB3|l*a<{e zp99kVHSX~}e|>OyAxGG?$xS z{0atQFYal4J4;#RKL0t$@txRmtR-s@2nGlRbvWa5%H{kk#Rl=sRSQvny(Z239OT^H z(gZ#KbSBnMUcymO(OpBQ^Y4BV&2!N1R1s^_epI;iH`>$*JXpMWWADReH;BAm9!|`t zlbnY23cFMk+GO38cU$~_3DWo*y?eo-xMW|Z&YQtp?wR#vKm0GHth0>+Uou;oCNZ_o z91PT?BVG^18saTWTT?te`^#?SmSo9Z<5IpDJ@71(e}DJc6C!j8g)7*sE=seIZB=>k zs(+v_gya21X5?X9b4mNa8Xv5gW^Hk*KQcv?%d_wd3@ClhLkC?Ghn0K`PhB~u?;JGa zYkJu-rNf6Y)yU@nv=6~8meF}&TKCYw1`Wiq;CWt;PJ+A7g~Zm(me zKgDmT@-2KDqPh^EgzTZ_k9}g0jIDJ<>`o)A|A66Nbir-xgQWV~-Ju9>Ze(@Xq+H#r zVgB%E?FiprLfE&gB>Kjc6%E=YWDhq#b0id8s+e;ve#Zsf7xhiYUFD}^8{!{MdKkg8=_K1Hkgav2Dm`RR*`H%_Af{lRq%HS;M`(b%Dto)+# zLdZb6N6=ykEkQv{5?Ot#;{wOe7a|}hp+_krl{T>D*8zFYP}mj;QfFgpfhv9JjV6i1 z=NXX@F1hp?e#M|tcQYZmD`4R3K$G9LC~rh8t177c`v{hRFOx>kEZ$(lj;n`JC~)Ct z68KH1dq~Y=qNK`x-8it75`Jt!s-Jp6S&=c52~by3rOzRUZ9vFGN(9liQ9CGgN@@MV zV`tLD`EMVt5t2YWG$@#3r7q%jvF3nv(+M~d?E@zBaK;KQW@rpp4sIcn>D|WoG zi&^Tqhg*i@_J~yIMb_~jM$RUZs`x|8p3y$`c%ExdYIHm5ci$gYHT+3Gb>B9Frqi;T z0soy9?MFm-HE|wz93SaI13KaR>a@7Mq9`4C@yw_f5xyd7GzG}(^~sJkjcln&qc6g0 z3XFCsMl5aTC9tEWHEy%>DsU|H%=!c+mWOCZqcDM(JoB--*E93|!H=zNbt=NNOSsM_ zN=?zOg!fW3gb#8)RtrroUvhcnIKLZCZoFN5KFK*`9c-pq5$1oStd3x;R~$v;?r)ot z)ZJ((@ua|4%xYL>NDLZGqCnY8*^s9{i#V{i#c4DS2aRbDRrDF`Ut4*$uU;D1V-*cK zb*G|xM*tmjPK+{rS*qdX=fu!|$8X zUpc|#C0&t62w8(jLsPgQF7_VL7FK)$A~7%3nbhk$oyloQ8-B^Lwhlf~N5#A^y-7fn4wB1)PQew>kD?Ue2`R$i>UB6TR9Ll|ECYl?- zf;Z)PzDdj^DN_ng$D)WwbQh32b4Y{RG`I^BfcSqp6kMA76oAaLdv3y+RKFm(_ zZt2B>=bEB7!9r>6T`x{*IM!Ag)?h9df&=#SVvZ*Kdl~`47{6LU!}RAovx}yaFXg!# zzd&`g@rPM$CSpmAWHLhNXmmr56w8ekzy~Hlnm6*1LSdYD-qI}}wKFb~MvW8w+A0%) zCmVH-|8Tf~^oX}-#M1>Y`*?^np2CON(GX_{^-@t{zvgkIIS!;9t=JlWoJo;mp6|2s%K1kMM3qlsGZ-C~Xe#d`Mv`J>w;XI)B&a_VCB-y7m71*ts z@ikbP9K9udVKea`<>K(9bAG@)GSPw>M}l^8-`gU7s;(xA&i~`91hMyHfSc=eHeNS* zafDFPW%)A$q$RhVzd&Mt)^`Wjp}OuucVdyskM;%-+W6zhUYWY{6cT*6j!R@v)G92g zR6>Pt{tZ_KmF8c1lNAep6Je{$q=>Lp0r`|TS}da-w!;fw`r;4$sP|ctYXK?qN%tg} zPaJP7l_s*41l*)laDlM`Pryj4K+pI6>nSwATp|abssQsBUXL;KEGkK%d2ot2Z=0Bq z>K|O)()-3fl>d})^Bw7L5lTOLNBMK0>{9%7!pYj85f$Oi8ANxZ;~UZ1Pe)$|#nvIb zhmG9qo!FMVxqeA>N_v|>hOFUV7SrQN0hBO z`YIm3m-U^@?nbW>qx3e~uG^-3R~z@+9r7tYBEeUALC?-fCjk{*ZRjENo%rhUER5(q zn8dQeu9iu*^izHLS?SF%H?Ik`k!G2khrQ7kiD94N%TMDCXIW;pZ3TPxY=1me{VKM9 zbWIi&J9;tp5$Du>kmd63h>O&PU*?k!(*T-38x*K; zrN~t7gI8_|wNPBp;!jr<;3^zsxi`Gx9^5Njb+BEboXTP6Sv$^0nVwKWna*}+{3^e3 z-o<_gq}?;DE>T%ICk|e49yu9$6NQ*7)51Tayi_@Z%r(tT%7D*L$#_b_{ByJJ z)5J5>!0tfeA}efb53cu1Ox8qJq_x=Hs!H>p#MkgKgE zJi$3fLY;0{)CX>sCn&yFKnJ$+)0zAUiZG#RZ&)r)UrOM6b@%SCUCP4wqXgsB65O}L z_6`Bqjr8tqqHP6dVcvQr6Iq)Sai26639=jT9U|(-md2ha=e%Zt@t7KrNZ4h%iHbNdZ>>qoM=mbqaxS8gc zMEytdwYsI3eC@tHaok^%uJB|)MwgH~Kl^~l=F3zix|7mRxf{$_L?;nM>I6iL2vSZ&{eMjO><%rd zuK$#N@R*jKaA(>7WJ9 z==I5G&sW@tFCKn0G_XPYE|XyLp_?}LYg^EV=RZ=rBX2#@GnJ5M<#s=z~QR-U1 zCtGJFeT{?<#?~Qn18?T|*F2O<_PM5%ddvU3mQ@fylv1Qm=}y&MX*qPWRQih%cVE4M zB#N6r=3l;cR6E#vF|=7%)kH)}WD5+A4A&?)(ds5%RN#uM(B9*6( zayf;f8+M9>7Ou2D$rD0UBM@i@`Bo5LSjm!+K|#oQ`SMXDRHt}jSP%xDYQ!uK59@lL zG;Cb{khpbU@B)`r?~WmN{ti3`5UOM!a^U#OjqjG{avO~}tWvcdnRBD~-7kQ@VFMd?=-77N_(D+^rJ z_?|~iJ(97uXR4m47d1#u$m#C-(hjLKo^@`d$AV;XoKS$Un|j6DI~E%Go{Hm?NY=Tc z8p=8!pw908*-;9}ox&fCKPs>c+wfpb_<4KAMU;2*pgC8G{gy`+vCPLQy^&1YfTYBV zCW$zt&k%`kbVu`_nco~>emyJ2R4JH0`F!~SD}Gce>D3Fw&gVoq`3uNlf`p4RH~!h1 zrmy!HHdZW+vaY`$I9M@m0-hS&PoA8iz>Oxd5Yb4HUW(2)e;nNtknv9V&~O{+!f1q9x%#Y5R#wv+NX%>?LI8dfk;i}q^r#ZM0gD*}txpveiihW5j{=(* zl)iJ2zwb2wX%Op&tJyexdVVMfuiXO5y^cW(9PXd{aX^C}Yd^z3p z=}nYPBST}7z?|P($;rQqFF&^RZ)B8Q106QM2xG$Vsk=_Za3VfhC0at-PvVaP+&cDd zj=#I6^y!|L9LKP|7sUac-98|bTpIbR3?c+RTV2MYdf0L{j;LlJ$JSNA4v*4%qR5c#d4=JGN zS|~9H^er?_=D%@L^?zL~|9^dWw4anS$(Oy0K;s0U;MA+`t_n-TNs1uHDZ(DsFoR!xyy=pTt z{W;lA;`X|`%9Pps8XN_El|j+L z&8uYk-yzrnjRAC6fPn$AvXEHsNStf|0u6`-ibryAM~GkHS9xO4^BWZkgpJ0}HIFy3 z?6NKy2jq@?^yg;80^xM4>yEQw^GU&>pK^+AslAI+a!On2Ayl-=sW8#UO*~<)#acHe z^5lAMOK73!u#*mu`QE(Yc;)x%gaBH?g^0bY78kq!?GSsAi{Z_zs;cF!+^x%OaZr0R zbg%1u$|LS?9Twyfoli?s)I63bixzsQ=SIGLy`SI0MO3433)tSL8nRb*Op3~DSmQTb zwEwgEob|DBs>Ipv1z#m1>NqCEKg#~gDaxKy#8*X+=O9nrVGnsSG-T>nTA@$+LN!hTzClmd1Ycl-;(Y3*6T%r0C@$PD@|%%&wdp^i6wVAoj{>pp95Cc3rw? z06jU-cAXR3sLyqv=+Y6-PC^_jR}todz=j?3_(ky*x7>UrJzMML2!FrIw=J)SA7*q| z{KF#G)%+-ex?>a)E9g~|{#?B43X*vzpLa2ZVIzE=s9!+pq=k;pFuC z3AuC%zZ-I-+Bi5A;H4}EW=MrcB5rqV4_#nO(d936!l@Wsy#2WIjqxK{Isa4mG$QA% zy$_%FAp}-ir?=h9cw%I8LSdpR;LQi|jV!mVgVBPQW)`Zi+RJmQ4yTN4)Db(?ZEBaF zYF=E{h@Ti|C6@cTI2cw?{N>h;`=;KJ`e^RHmx!qC6B&49G{TPcs}c`{g73b}7+-J{ zch>y<%{jdYVS(>=QHM)+EPyXD<~fs@KFkDoSA>nu>si?*rB0}92++6xU4NO3ZOEOV z`Zcw0b^SmNzDsmA@@nXuRkuZRo3DYOqSkI9vCZtYUH~e zj)#EcNK62Xog(6o-6CEN-Zs4IX?X28dV%(8*WYWzH;h2bf3P{7z00<}+4J3eDY%gZ ztC!ZWL4~3tH0B_4sjG{hkDhzPd-qyEdI7Z1{gk->8?!D_-=X?KB z)8V&3|~nj2{meRJ#Y<|w7fZcNPEfu}^ZOCPxf zW2`kV(y(7Nq{Q4>6)}C;^}5;SI|E+mcaLP0hyim8+wDQmy}HQ9G#OKFHCEpSQ;f8Q z*Ta8U+MWzn+cV$0Q>7h58{U&hg$qqdKfd?I?u+hakZ=$pq_6GEU1B_1BNEkR{Jkt? zP4iN(SwLFcT^Y(G#S`HdbDgo?YzkecM~>NWY|;s2{j;&-@u0vuEJ!A5&)t4tD-)b65IJu2F_JoBt2STllw5`k{B2fM@g?VFKNd;5)5=*@J4}c&9mx1ugp}hnR^CL*P#AgWBxnWm3mbL kz7qkujpItmEB_G{L%78$iS+T#t(_2bHLqzDUBCtX4^PrmiU0rr literal 0 HcmV?d00001 diff --git a/en/chapter_heap/top_k.assets/top_k_heap_step3.png b/en/chapter_heap/top_k.assets/top_k_heap_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..99ee5ec5cb2f428f3109fc48dc797ba057943e3c GIT binary patch literal 16415 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/top_k.assets/top_k_heap_step4.png b/en/chapter_heap/top_k.assets/top_k_heap_step4.png new file mode 100644 index 0000000000000000000000000000000000000000..b70e2177bd6b82cedca05961362288c9a34bd641 GIT binary patch literal 19834 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/top_k.assets/top_k_heap_step5.png b/en/chapter_heap/top_k.assets/top_k_heap_step5.png new file mode 100644 index 0000000000000000000000000000000000000000..09620a8d56895a3b3d655832ec63c332ea284b3f GIT binary patch literal 20727 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

    Zyf*>vzDP)6plAS4ugPZ`sQk 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 Vj~3W%MqK@6u(5D3uQVkm{u8CI9C-i$ literal 0 HcmV?d00001 diff --git a/en/chapter_heap/top_k.assets/top_k_heap_step6.png b/en/chapter_heap/top_k.assets/top_k_heap_step6.png new file mode 100644 index 0000000000000000000000000000000000000000..44180cfd2649b92bbcb0d90c7ebab6ac13caf682 GIT binary patch literal 23325 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/top_k.assets/top_k_heap_step7.png b/en/chapter_heap/top_k.assets/top_k_heap_step7.png new file mode 100644 index 0000000000000000000000000000000000000000..32c07b636a58f09a98c564744e4351962a5780b3 GIT binary patch literal 19953 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 QrGtBuvzBLyjoj}23&VN@GXMYp literal 0 HcmV?d00001 diff --git a/en/chapter_heap/top_k.assets/top_k_heap_step9.png b/en/chapter_heap/top_k.assets/top_k_heap_step9.png new file mode 100644 index 0000000000000000000000000000000000000000..804af12d2f48ddafbe4f4a94250ffc1c699a88c7 GIT binary patch literal 16006 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/top_k.assets/top_k_sorting.png b/en/chapter_heap/top_k.assets/top_k_sorting.png new file mode 100644 index 0000000000000000000000000000000000000000..3f6514c57bb5a51a251539cacc61c9a7342ab11a GIT binary patch literal 10160 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/top_k.assets/top_k_traversal.png b/en/chapter_heap/top_k.assets/top_k_traversal.png new file mode 100644 index 0000000000000000000000000000000000000000..988e26121f8ad0eddd4444c8ec366f535c61e65e GIT binary patch literal 17271 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + 8.3 Top-k Problem - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    8.3   Top-k problem

    +
    +

    Question

    +

    Given an unordered array nums of length \(n\), return the largest \(k\) elements in the array.

    +
    +

    For this problem, we will first introduce two straightforward solutions, then explain a more efficient heap-based method.

    +

    8.3.1   Method 1: Iterative selection

    +

    We can perform \(k\) rounds of iterations as shown in the Figure 8-6 , extracting the \(1^{st}\), \(2^{nd}\), \(\dots\), \(k^{th}\) largest elements in each round, with a time complexity of \(O(nk)\).

    +

    This method is only suitable when \(k \ll n\), as the time complexity approaches \(O(n^2)\) when \(k\) is close to \(n\), which is very time-consuming.

    +

    Iteratively finding the largest k elements

    +

    Figure 8-6   Iteratively finding the largest k elements

    + +
    +

    Tip

    +

    When \(k = n\), we can obtain a complete ordered sequence, which is equivalent to the "selection sort" algorithm.

    +
    +

    8.3.2   Method 2: Sorting

    +

    As shown in the Figure 8-7 , we can first sort the array nums and then return the last \(k\) elements, with a time complexity of \(O(n \log n)\).

    +

    Clearly, this method "overachieves" the task, as we only need to find the largest \(k\) elements, without the need to sort the other elements.

    +

    Sorting to find the largest k elements

    +

    Figure 8-7   Sorting to find the largest k elements

    + +

    8.3.3   Method 3: Heap

    +

    We can solve the Top-k problem more efficiently based on heaps, as shown in the following process.

    +
      +
    1. Initialize a min heap, where the top element is the smallest.
      2. +
    2. First, insert the first \(k\) elements of the array into the heap.
      3. +
    3. Starting from the \(k + 1^{th}\) element, if the current element is greater than the top element of the heap, remove the top element of the heap and insert the current element into the heap.
      4. +
    4. After completing the traversal, the heap contains the largest \(k\) elements.
      5. +
    +
    +
    +
    +

    Find the largest k elements based on heap

    +
    +
    +

    top_k_heap_step2

    +
    +
    +

    top_k_heap_step3

    +
    +
    +

    top_k_heap_step4

    +
    +
    +

    top_k_heap_step5

    +
    +
    +

    top_k_heap_step6

    +
    +
    +

    top_k_heap_step7

    +
    +
    +

    top_k_heap_step8

    +
    +
    +

    top_k_heap_step9

    +
    +
    +
    +

    Figure 8-8   Find the largest k elements based on heap

    + +

    Example code is as follows:

    +
    +
    +
    +
    top_k.py
    def top_k_heap(nums: list[int], k: int) -> list[int]:
+    """基于堆查找数组中最大的 k 个元素"""
+    # 初始化小顶堆
+    heap = []
+    # 将数组的前 k 个元素入堆
+    for i in range(k):
+        heapq.heappush(heap, nums[i])
+    # 从第 k+1 个元素开始，保持堆的长度为 k
+    for i in range(k, len(nums)):
+        # 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if nums[i] > heap[0]:
+            heapq.heappop(heap)
+            heapq.heappush(heap, nums[i])
+    return heap
+
    +
    +
    +
    top_k.cpp
    /* 基于堆查找数组中最大的 k 个元素 */
+priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
+    // 初始化小顶堆
+    priority_queue<int, vector<int>, greater<int>> heap;
+    // 将数组的前 k 个元素入堆
+    for (int i = 0; i < k; i++) {
+        heap.push(nums[i]);
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for (int i = k; i < nums.size(); i++) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if (nums[i] > heap.top()) {
+            heap.pop();
+            heap.push(nums[i]);
+        }
+    }
+    return heap;
+}
+
    +
    +
    +
    top_k.java
    /* 基于堆查找数组中最大的 k 个元素 */
+Queue<Integer> topKHeap(int[] nums, int k) {
+    // 初始化小顶堆
+    Queue<Integer> heap = new PriorityQueue<Integer>();
+    // 将数组的前 k 个元素入堆
+    for (int i = 0; i < k; i++) {
+        heap.offer(nums[i]);
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for (int i = k; i < nums.length; i++) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if (nums[i] > heap.peek()) {
+            heap.poll();
+            heap.offer(nums[i]);
+        }
+    }
+    return heap;
+}
+
    +
    +
    +
    top_k.cs
    /* 基于堆查找数组中最大的 k 个元素 */
+PriorityQueue<int, int> TopKHeap(int[] nums, int k) {
+    // 初始化小顶堆
+    PriorityQueue<int, int> heap = new();
+    // 将数组的前 k 个元素入堆
+    for (int i = 0; i < k; i++) {
+        heap.Enqueue(nums[i], nums[i]);
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for (int i = k; i < nums.Length; i++) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if (nums[i] > heap.Peek()) {
+            heap.Dequeue();
+            heap.Enqueue(nums[i], nums[i]);
+        }
+    }
+    return heap;
+}
+
    +
    +
    +
    top_k.go
    /* 基于堆查找数组中最大的 k 个元素 */
+func topKHeap(nums []int, k int) *minHeap {
+    // 初始化小顶堆
+    h := &minHeap{}
+    heap.Init(h)
+    // 将数组的前 k 个元素入堆
+    for i := 0; i < k; i++ {
+        heap.Push(h, nums[i])
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for i := k; i < len(nums); i++ {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if nums[i] > h.Top().(int) {
+            heap.Pop(h)
+            heap.Push(h, nums[i])
+        }
+    }
+    return h
+}
+
    +
    +
    +
    top_k.swift
    /* 基于堆查找数组中最大的 k 个元素 */
+func topKHeap(nums: [Int], k: Int) -> [Int] {
+    // 初始化一个小顶堆，并将前 k 个元素建堆
+    var heap = Heap(nums.prefix(k))
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for i in nums.indices.dropFirst(k) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if nums[i] > heap.min()! {
+            _ = heap.removeMin()
+            heap.insert(nums[i])
+        }
+    }
+    return heap.unordered
+}
+
    +
    +
    +
    top_k.js
    /* 元素入堆 */
+function pushMinHeap(maxHeap, val) {
+    // 元素取反
+    maxHeap.push(-val);
+}
+
+/* 元素出堆 */
+function popMinHeap(maxHeap) {
+    // 元素取反
+    return -maxHeap.pop();
+}
+
+/* 访问堆顶元素 */
+function peekMinHeap(maxHeap) {
+    // 元素取反
+    return -maxHeap.peek();
+}
+
+/* 取出堆中元素 */
+function getMinHeap(maxHeap) {
+    // 元素取反
+    return maxHeap.getMaxHeap().map((num) => -num);
+}
+
+/* 基于堆查找数组中最大的 k 个元素 */
+function topKHeap(nums, k) {
+    // 初始化小顶堆
+    // 请注意：我们将堆中所有元素取反，从而用大顶堆来模拟小顶堆
+    const maxHeap = new MaxHeap([]);
+    // 将数组的前 k 个元素入堆
+    for (let i = 0; i < k; i++) {
+        pushMinHeap(maxHeap, nums[i]);
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for (let i = k; i < nums.length; i++) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if (nums[i] > peekMinHeap(maxHeap)) {
+            popMinHeap(maxHeap);
+            pushMinHeap(maxHeap, nums[i]);
+        }
+    }
+    // 返回堆中元素
+    return getMinHeap(maxHeap);
+}
+
    +
    +
    +
    top_k.ts
    /* 元素入堆 */
+function pushMinHeap(maxHeap: MaxHeap, val: number): void {
+    // 元素取反
+    maxHeap.push(-val);
+}
+
+/* 元素出堆 */
+function popMinHeap(maxHeap: MaxHeap): number {
+    // 元素取反
+    return -maxHeap.pop();
+}
+
+/* 访问堆顶元素 */
+function peekMinHeap(maxHeap: MaxHeap): number {
+    // 元素取反
+    return -maxHeap.peek();
+}
+
+/* 取出堆中元素 */
+function getMinHeap(maxHeap: MaxHeap): number[] {
+    // 元素取反
+    return maxHeap.getMaxHeap().map((num: number) => -num);
+}
+
+/* 基于堆查找数组中最大的 k 个元素 */
+function topKHeap(nums: number[], k: number): number[] {
+    // 初始化小顶堆
+    // 请注意：我们将堆中所有元素取反，从而用大顶堆来模拟小顶堆
+    const maxHeap = new MaxHeap([]);
+    // 将数组的前 k 个元素入堆
+    for (let i = 0; i < k; i++) {
+        pushMinHeap(maxHeap, nums[i]);
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for (let i = k; i < nums.length; i++) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if (nums[i] > peekMinHeap(maxHeap)) {
+            popMinHeap(maxHeap);
+            pushMinHeap(maxHeap, nums[i]);
+        }
+    }
+    // 返回堆中元素
+    return getMinHeap(maxHeap);
+}
+
    +
    +
    +
    top_k.dart
    /* 基于堆查找数组中最大的 k 个元素 */
+MinHeap topKHeap(List<int> nums, int k) {
+  // 初始化小顶堆，将数组的前 k 个元素入堆
+  MinHeap heap = MinHeap(nums.sublist(0, k));
+  // 从第 k+1 个元素开始，保持堆的长度为 k
+  for (int i = k; i < nums.length; i++) {
+    // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+    if (nums[i] > heap.peek()) {
+      heap.pop();
+      heap.push(nums[i]);
+    }
+  }
+  return heap;
+}
+
    +
    +
    +
    top_k.rs
    /* 基于堆查找数组中最大的 k 个元素 */
+fn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {
+    // BinaryHeap 是大顶堆，使用 Reverse 将元素取反，从而实现小顶堆
+    let mut heap = BinaryHeap::<Reverse<i32>>::new();
+    // 将数组的前 k 个元素入堆
+    for &num in nums.iter().take(k) {
+        heap.push(Reverse(num));
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for &num in nums.iter().skip(k) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if num > heap.peek().unwrap().0 {
+            heap.pop();
+            heap.push(Reverse(num));
+        }
+    }
+    heap
+}
+
    +
    +
    +
    top_k.c
    /* 元素入堆 */
+void pushMinHeap(MaxHeap *maxHeap, int val) {
+    // 元素取反
+    push(maxHeap, -val);
+}
+
+/* 元素出堆 */
+int popMinHeap(MaxHeap *maxHeap) {
+    // 元素取反
+    return -pop(maxHeap);
+}
+
+/* 访问堆顶元素 */
+int peekMinHeap(MaxHeap *maxHeap) {
+    // 元素取反
+    return -peek(maxHeap);
+}
+
+/* 取出堆中元素 */
+int *getMinHeap(MaxHeap *maxHeap) {
+    // 将堆中所有元素取反并存入 res 数组
+    int *res = (int *)malloc(maxHeap->size * sizeof(int));
+    for (int i = 0; i < maxHeap->size; i++) {
+        res[i] = -maxHeap->data[i];
+    }
+    return res;
+}
+
+/* 取出堆中元素 */
+int *getMinHeap(MaxHeap *maxHeap) {
+    // 将堆中所有元素取反并存入 res 数组
+    int *res = (int *)malloc(maxHeap->size * sizeof(int));
+    for (int i = 0; i < maxHeap->size; i++) {
+        res[i] = -maxHeap->data[i];
+    }
+    return res;
+}
+
+// 基于堆查找数组中最大的 k 个元素的函数
+int *topKHeap(int *nums, int sizeNums, int k) {
+    // 初始化小顶堆
+    // 请注意：我们将堆中所有元素取反，从而用大顶堆来模拟小顶堆
+    int *empty = (int *)malloc(0);
+    MaxHeap *maxHeap = newMaxHeap(empty, 0);
+    // 将数组的前 k 个元素入堆
+    for (int i = 0; i < k; i++) {
+        pushMinHeap(maxHeap, nums[i]);
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for (int i = k; i < sizeNums; i++) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if (nums[i] > peekMinHeap(maxHeap)) {
+            popMinHeap(maxHeap);
+            pushMinHeap(maxHeap, nums[i]);
+        }
+    }
+    int *res = getMinHeap(maxHeap);
+    // 释放内存
+    delMaxHeap(maxHeap);
+    return res;
+}
+
    +
    +
    +
    top_k.kt
    /* 基于堆查找数组中最大的 k 个元素 */
+fun topKHeap(nums: IntArray, k: Int): Queue<Int> {
+    // 初始化小顶堆
+    val heap = PriorityQueue<Int>()
+    // 将数组的前 k 个元素入堆
+    for (i in 0..<k) {
+        heap.offer(nums[i])
+    }
+    // 从第 k+1 个元素开始，保持堆的长度为 k
+    for (i in k..<nums.size) {
+        // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆
+        if (nums[i] > heap.peek()) {
+            heap.poll()
+            heap.offer(nums[i])
+        }
+    }
+    return heap
+}
+
    +
    +
    +
    top_k.rb
    [class]{}-[func]{top_k_heap}
+
    +
    +
    +
    top_k.zig
    [class]{}-[func]{topKHeap}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    A total of \(n\) rounds of heap insertions and deletions are performed, with the maximum heap size being \(k\), hence the time complexity is \(O(n \log k)\). This method is very efficient; when \(k\) is small, the time complexity tends towards \(O(n)\); when \(k\) is large, the time complexity will not exceed \(O(n \log n)\).

    +

    Additionally, this method is suitable for scenarios with dynamic data streams. By continuously adding data, we can maintain the elements within the heap, thereby achieving dynamic updates of the largest \(k\) elements.

    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_introduction/algorithms_are_everywhere/index.html b/en/chapter_introduction/algorithms_are_everywhere/index.html index 872c9c9f4..c85b85909 100644 --- a/en/chapter_introduction/algorithms_are_everywhere/index.html +++ b/en/chapter_introduction/algorithms_are_everywhere/index.html @@ -1434,6 +1434,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_introduction/index.html b/en/chapter_introduction/index.html index 5a83ff97a..54fe2a2a0 100644 --- a/en/chapter_introduction/index.html +++ b/en/chapter_introduction/index.html @@ -1424,6 +1424,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_introduction/summary/index.html b/en/chapter_introduction/summary/index.html index fcebed6e6..de1bea0a1 100644 --- a/en/chapter_introduction/summary/index.html +++ b/en/chapter_introduction/summary/index.html @@ -1434,6 +1434,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_introduction/what_is_dsa/index.html b/en/chapter_introduction/what_is_dsa/index.html index d08c13a88..e12a93841 100644 --- a/en/chapter_introduction/what_is_dsa/index.html +++ b/en/chapter_introduction/what_is_dsa/index.html @@ -1491,6 +1491,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_preface/about_the_book/index.html b/en/chapter_preface/about_the_book/index.html index d4ce542cc..7d57e2698 100644 --- a/en/chapter_preface/about_the_book/index.html +++ b/en/chapter_preface/about_the_book/index.html @@ -1491,6 +1491,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_preface/index.html b/en/chapter_preface/index.html index bc324a60e..b7547c442 100644 --- a/en/chapter_preface/index.html +++ b/en/chapter_preface/index.html @@ -1422,6 +1422,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_preface/suggestions/index.html b/en/chapter_preface/suggestions/index.html index 3e3a98749..0139710cf 100644 --- a/en/chapter_preface/suggestions/index.html +++ b/en/chapter_preface/suggestions/index.html @@ -1509,6 +1509,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_preface/summary/index.html b/en/chapter_preface/summary/index.html index 7f301f825..8fbfa5a21 100644 --- a/en/chapter_preface/summary/index.html +++ b/en/chapter_preface/summary/index.html @@ -1434,6 +1434,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_stack_and_queue/deque/index.html b/en/chapter_stack_and_queue/deque/index.html index d1ec32d81..5005db3dc 100644 --- a/en/chapter_stack_and_queue/deque/index.html +++ b/en/chapter_stack_and_queue/deque/index.html @@ -1515,6 +1515,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_stack_and_queue/index.html b/en/chapter_stack_and_queue/index.html index e8e2264ae..757de3e82 100644 --- a/en/chapter_stack_and_queue/index.html +++ b/en/chapter_stack_and_queue/index.html @@ -1424,6 +1424,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_stack_and_queue/queue/index.html b/en/chapter_stack_and_queue/queue/index.html index 8f116cf0c..c4b5f7e81 100644 --- a/en/chapter_stack_and_queue/queue/index.html +++ b/en/chapter_stack_and_queue/queue/index.html @@ -1515,6 +1515,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_stack_and_queue/stack/index.html b/en/chapter_stack_and_queue/stack/index.html index 228c0c7cc..7bf4504ab 100644 --- a/en/chapter_stack_and_queue/stack/index.html +++ b/en/chapter_stack_and_queue/stack/index.html @@ -1524,6 +1524,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_stack_and_queue/summary/index.html b/en/chapter_stack_and_queue/summary/index.html index 8aafee1d0..7036014c4 100644 --- a/en/chapter_stack_and_queue/summary/index.html +++ b/en/chapter_stack_and_queue/summary/index.html @@ -1482,6 +1482,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/chapter_tree/array_representation_of_tree.assets/array_representation_binary_tree.png b/en/chapter_tree/array_representation_of_tree.assets/array_representation_binary_tree.png new file mode 100644 index 0000000000000000000000000000000000000000..3480c571815847ce73bdcc2585cabb1f3bd15aa9 GIT binary patch literal 27870 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

    `a9C)%pp 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 Kx<=Cc&Hn&4x)u`v literal 0 HcmV?d00001 diff --git a/en/chapter_tree/array_representation_of_tree.assets/array_representation_complete_binary_tree.png b/en/chapter_tree/array_representation_of_tree.assets/array_representation_complete_binary_tree.png new file mode 100644 index 0000000000000000000000000000000000000000..753ddcc2702f97b1fecd24b9a0806a8fcfa2b1ea GIT binary patch literal 19214 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 IZ|s)vA3;ngRR910 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/array_representation_of_tree.assets/array_representation_with_empty.png b/en/chapter_tree/array_representation_of_tree.assets/array_representation_with_empty.png new file mode 100644 index 0000000000000000000000000000000000000000..3c0184f3f3810df40742966ceee79473d15a55d5 GIT binary patch literal 22549 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 GBL4{^l`jYY literal 0 HcmV?d00001 diff --git a/en/chapter_tree/array_representation_of_tree/index.html b/en/chapter_tree/array_representation_of_tree/index.html new file mode 100644 index 000000000..14c41ce87 --- /dev/null +++ b/en/chapter_tree/array_representation_of_tree/index.html @@ -0,0 +1,3555 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 7.3 Array Representation of Tree - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

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

    7.3   Array representation of binary trees

    +

    Under the linked list representation, the storage unit of a binary tree is a node TreeNode, with nodes connected by pointers. The basic operations of binary trees under the linked list representation were introduced in the previous section.

    +

    So, can we use an array to represent a binary tree? The answer is yes.

    +

    7.3.1   Representing perfect binary trees

    +

    Let's analyze a simple case first. Given a perfect binary tree, we store all nodes in an array according to the order of level-order traversal, where each node corresponds to a unique array index.

    +

    Based on the characteristics of level-order traversal, we can deduce a "mapping formula" between the index of a parent node and its children: If a node's index is \(i\), then the index of its left child is \(2i + 1\) and the right child is \(2i + 2\). The Figure 7-12 shows the mapping relationship between the indices of various nodes.

    +

    Array representation of a perfect binary tree

    +

    Figure 7-12   Array representation of a perfect binary tree

    + +

    The mapping formula plays a role similar to the node references (pointers) in linked lists. Given any node in the array, we can access its left (right) child node using the mapping formula.

    +

    7.3.2   Representing any binary tree

    +

    Perfect binary trees are a special case; there are often many None values in the middle levels of a binary tree. Since the sequence of level-order traversal does not include these None values, we cannot solely rely on this sequence to deduce the number and distribution of None values. This means that multiple binary tree structures can match the same level-order traversal sequence.

    +

    As shown in the Figure 7-13 , given a non-perfect binary tree, the above method of array representation fails.

    +

    Level-order traversal sequence corresponds to multiple binary tree possibilities

    +

    Figure 7-13   Level-order traversal sequence corresponds to multiple binary tree possibilities

    + +

    To solve this problem, we can consider explicitly writing out all None values in the level-order traversal sequence. As shown in the following figure, after this treatment, the level-order traversal sequence can uniquely represent a binary tree. Example code is as follows:

    +
    +
    +
    +
    # Array representation of a binary tree
+# Using None to represent empty slots
+tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using the maximum integer value INT_MAX to mark empty slots
+vector<int> tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using the Integer wrapper class allows for using null to mark empty slots
+Integer[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using nullable int (int?) allows for using null to mark empty slots
+int?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using an any type slice, allowing for nil to mark empty slots
+tree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using optional Int (Int?) allows for using nil to mark empty slots
+let tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using null to represent empty slots
+let tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using null to represent empty slots
+let tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using nullable int (int?) allows for using null to mark empty slots
+List<int?> tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using None to mark empty slots
+let tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using the maximum int value to mark empty slots, therefore, node values must not be INT_MAX
+int tree[] = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};
+
    +
    +
    +
    /* Array representation of a binary tree */
+// Using null to represent empty slots
+val tree = mutableListOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )
+
    +
    +
    +
    
+
    +
    +
    +
    
+
    +
    +
    +
    +

    Array representation of any type of binary tree

    +

    Figure 7-14   Array representation of any type of binary tree

    + +

    It's worth noting that complete binary trees are very suitable for array representation. Recalling the definition of a complete binary tree, None appears only at the bottom level and towards the right, meaning all None values definitely appear at the end of the level-order traversal sequence.

    +

    This means that when using an array to represent a complete binary tree, it's possible to omit storing all None values, which is very convenient. The Figure 7-15 gives an example.

    +

    Array representation of a complete binary tree

    +

    Figure 7-15   Array representation of a complete binary tree

    + +

    The following code implements a binary tree based on array representation, including the following operations:

    +
      +
    • Given a node, obtain its value, left (right) child node, and parent node.
      • +
    • Obtain the preorder, inorder, postorder, and level-order traversal sequences.
      • +
    +
    +
    +
    +
    array_binary_tree.py
    class ArrayBinaryTree:
+    """数组表示下的二叉树类"""
+
+    def __init__(self, arr: list[int | None]):
+        """构造方法"""
+        self._tree = list(arr)
+
+    def size(self):
+        """列表容量"""
+        return len(self._tree)
+
+    def val(self, i: int) -> int:
+        """获取索引为 i 节点的值"""
+        # 若索引越界，则返回 None ，代表空位
+        if i < 0 or i >= self.size():
+            return None
+        return self._tree[i]
+
+    def left(self, i: int) -> int | None:
+        """获取索引为 i 节点的左子节点的索引"""
+        return 2 * i + 1
+
+    def right(self, i: int) -> int | None:
+        """获取索引为 i 节点的右子节点的索引"""
+        return 2 * i + 2
+
+    def parent(self, i: int) -> int | None:
+        """获取索引为 i 节点的父节点的索引"""
+        return (i - 1) // 2
+
+    def level_order(self) -> list[int]:
+        """层序遍历"""
+        self.res = []
+        # 直接遍历数组
+        for i in range(self.size()):
+            if self.val(i) is not None:
+                self.res.append(self.val(i))
+        return self.res
+
+    def dfs(self, i: int, order: str):
+        """深度优先遍历"""
+        if self.val(i) is None:
+            return
+        # 前序遍历
+        if order == "pre":
+            self.res.append(self.val(i))
+        self.dfs(self.left(i), order)
+        # 中序遍历
+        if order == "in":
+            self.res.append(self.val(i))
+        self.dfs(self.right(i), order)
+        # 后序遍历
+        if order == "post":
+            self.res.append(self.val(i))
+
+    def pre_order(self) -> list[int]:
+        """前序遍历"""
+        self.res = []
+        self.dfs(0, order="pre")
+        return self.res
+
+    def in_order(self) -> list[int]:
+        """中序遍历"""
+        self.res = []
+        self.dfs(0, order="in")
+        return self.res
+
+    def post_order(self) -> list[int]:
+        """后序遍历"""
+        self.res = []
+        self.dfs(0, order="post")
+        return self.res
+
    +
    +
    +
    array_binary_tree.cpp
    /* 数组表示下的二叉树类 */
+class ArrayBinaryTree {
+  public:
+    /* 构造方法 */
+    ArrayBinaryTree(vector<int> arr) {
+        tree = arr;
+    }
+
+    /* 列表容量 */
+    int size() {
+        return tree.size();
+    }
+
+    /* 获取索引为 i 节点的值 */
+    int val(int i) {
+        // 若索引越界，则返回 INT_MAX ，代表空位
+        if (i < 0 || i >= size())
+            return INT_MAX;
+        return tree[i];
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    int left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    int right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    int parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    /* 层序遍历 */
+    vector<int> levelOrder() {
+        vector<int> res;
+        // 直接遍历数组
+        for (int i = 0; i < size(); i++) {
+            if (val(i) != INT_MAX)
+                res.push_back(val(i));
+        }
+        return res;
+    }
+
+    /* 前序遍历 */
+    vector<int> preOrder() {
+        vector<int> res;
+        dfs(0, "pre", res);
+        return res;
+    }
+
+    /* 中序遍历 */
+    vector<int> inOrder() {
+        vector<int> res;
+        dfs(0, "in", res);
+        return res;
+    }
+
+    /* 后序遍历 */
+    vector<int> postOrder() {
+        vector<int> res;
+        dfs(0, "post", res);
+        return res;
+    }
+
+  private:
+    vector<int> tree;
+
+    /* 深度优先遍历 */
+    void dfs(int i, string order, vector<int> &res) {
+        // 若为空位，则返回
+        if (val(i) == INT_MAX)
+            return;
+        // 前序遍历
+        if (order == "pre")
+            res.push_back(val(i));
+        dfs(left(i), order, res);
+        // 中序遍历
+        if (order == "in")
+            res.push_back(val(i));
+        dfs(right(i), order, res);
+        // 后序遍历
+        if (order == "post")
+            res.push_back(val(i));
+    }
+};
+
    +
    +
    +
    array_binary_tree.java
    /* 数组表示下的二叉树类 */
+class ArrayBinaryTree {
+    private List<Integer> tree;
+
+    /* 构造方法 */
+    public ArrayBinaryTree(List<Integer> arr) {
+        tree = new ArrayList<>(arr);
+    }
+
+    /* 列表容量 */
+    public int size() {
+        return tree.size();
+    }
+
+    /* 获取索引为 i 节点的值 */
+    public Integer val(int i) {
+        // 若索引越界，则返回 null ，代表空位
+        if (i < 0 || i >= size())
+            return null;
+        return tree.get(i);
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    public Integer left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    public Integer right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    public Integer parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    /* 层序遍历 */
+    public List<Integer> levelOrder() {
+        List<Integer> res = new ArrayList<>();
+        // 直接遍历数组
+        for (int i = 0; i < size(); i++) {
+            if (val(i) != null)
+                res.add(val(i));
+        }
+        return res;
+    }
+
+    /* 深度优先遍历 */
+    private void dfs(Integer i, String order, List<Integer> res) {
+        // 若为空位，则返回
+        if (val(i) == null)
+            return;
+        // 前序遍历
+        if ("pre".equals(order))
+            res.add(val(i));
+        dfs(left(i), order, res);
+        // 中序遍历
+        if ("in".equals(order))
+            res.add(val(i));
+        dfs(right(i), order, res);
+        // 后序遍历
+        if ("post".equals(order))
+            res.add(val(i));
+    }
+
+    /* 前序遍历 */
+    public List<Integer> preOrder() {
+        List<Integer> res = new ArrayList<>();
+        dfs(0, "pre", res);
+        return res;
+    }
+
+    /* 中序遍历 */
+    public List<Integer> inOrder() {
+        List<Integer> res = new ArrayList<>();
+        dfs(0, "in", res);
+        return res;
+    }
+
+    /* 后序遍历 */
+    public List<Integer> postOrder() {
+        List<Integer> res = new ArrayList<>();
+        dfs(0, "post", res);
+        return res;
+    }
+}
+
    +
    +
    +
    array_binary_tree.cs
    /* 数组表示下的二叉树类 */
+class ArrayBinaryTree(List<int?> arr) {
+    List<int?> tree = new(arr);
+
+    /* 列表容量 */
+    public int Size() {
+        return tree.Count;
+    }
+
+    /* 获取索引为 i 节点的值 */
+    public int? Val(int i) {
+        // 若索引越界，则返回 null ，代表空位
+        if (i < 0 || i >= Size())
+            return null;
+        return tree[i];
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    public int Left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    public int Right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    public int Parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    /* 层序遍历 */
+    public List<int> LevelOrder() {
+        List<int> res = [];
+        // 直接遍历数组
+        for (int i = 0; i < Size(); i++) {
+            if (Val(i).HasValue)
+                res.Add(Val(i)!.Value);
+        }
+        return res;
+    }
+
+    /* 深度优先遍历 */
+    void DFS(int i, string order, List<int> res) {
+        // 若为空位，则返回
+        if (!Val(i).HasValue)
+            return;
+        // 前序遍历
+        if (order == "pre")
+            res.Add(Val(i)!.Value);
+        DFS(Left(i), order, res);
+        // 中序遍历
+        if (order == "in")
+            res.Add(Val(i)!.Value);
+        DFS(Right(i), order, res);
+        // 后序遍历
+        if (order == "post")
+            res.Add(Val(i)!.Value);
+    }
+
+    /* 前序遍历 */
+    public List<int> PreOrder() {
+        List<int> res = [];
+        DFS(0, "pre", res);
+        return res;
+    }
+
+    /* 中序遍历 */
+    public List<int> InOrder() {
+        List<int> res = [];
+        DFS(0, "in", res);
+        return res;
+    }
+
+    /* 后序遍历 */
+    public List<int> PostOrder() {
+        List<int> res = [];
+        DFS(0, "post", res);
+        return res;
+    }
+}
+
    +
    +
    +
    array_binary_tree.go
    /* 数组表示下的二叉树类 */
+type arrayBinaryTree struct {
+    tree []any
+}
+
+/* 构造方法 */
+func newArrayBinaryTree(arr []any) *arrayBinaryTree {
+    return &arrayBinaryTree{
+        tree: arr,
+    }
+}
+
+/* 列表容量 */
+func (abt *arrayBinaryTree) size() int {
+    return len(abt.tree)
+}
+
+/* 获取索引为 i 节点的值 */
+func (abt *arrayBinaryTree) val(i int) any {
+    // 若索引越界，则返回 null ，代表空位
+    if i < 0 || i >= abt.size() {
+        return nil
+    }
+    return abt.tree[i]
+}
+
+/* 获取索引为 i 节点的左子节点的索引 */
+func (abt *arrayBinaryTree) left(i int) int {
+    return 2*i + 1
+}
+
+/* 获取索引为 i 节点的右子节点的索引 */
+func (abt *arrayBinaryTree) right(i int) int {
+    return 2*i + 2
+}
+
+/* 获取索引为 i 节点的父节点的索引 */
+func (abt *arrayBinaryTree) parent(i int) int {
+    return (i - 1) / 2
+}
+
+/* 层序遍历 */
+func (abt *arrayBinaryTree) levelOrder() []any {
+    var res []any
+    // 直接遍历数组
+    for i := 0; i < abt.size(); i++ {
+        if abt.val(i) != nil {
+            res = append(res, abt.val(i))
+        }
+    }
+    return res
+}
+
+/* 深度优先遍历 */
+func (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {
+    // 若为空位，则返回
+    if abt.val(i) == nil {
+        return
+    }
+    // 前序遍历
+    if order == "pre" {
+        *res = append(*res, abt.val(i))
+    }
+    abt.dfs(abt.left(i), order, res)
+    // 中序遍历
+    if order == "in" {
+        *res = append(*res, abt.val(i))
+    }
+    abt.dfs(abt.right(i), order, res)
+    // 后序遍历
+    if order == "post" {
+        *res = append(*res, abt.val(i))
+    }
+}
+
+/* 前序遍历 */
+func (abt *arrayBinaryTree) preOrder() []any {
+    var res []any
+    abt.dfs(0, "pre", &res)
+    return res
+}
+
+/* 中序遍历 */
+func (abt *arrayBinaryTree) inOrder() []any {
+    var res []any
+    abt.dfs(0, "in", &res)
+    return res
+}
+
+/* 后序遍历 */
+func (abt *arrayBinaryTree) postOrder() []any {
+    var res []any
+    abt.dfs(0, "post", &res)
+    return res
+}
+
    +
    +
    +
    array_binary_tree.swift
    /* 数组表示下的二叉树类 */
+class ArrayBinaryTree {
+    private var tree: [Int?]
+
+    /* 构造方法 */
+    init(arr: [Int?]) {
+        tree = arr
+    }
+
+    /* 列表容量 */
+    func size() -> Int {
+        tree.count
+    }
+
+    /* 获取索引为 i 节点的值 */
+    func val(i: Int) -> Int? {
+        // 若索引越界，则返回 null ，代表空位
+        if i < 0 || i >= size() {
+            return nil
+        }
+        return tree[i]
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    func left(i: Int) -> Int {
+        2 * i + 1
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    func right(i: Int) -> Int {
+        2 * i + 2
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    func parent(i: Int) -> Int {
+        (i - 1) / 2
+    }
+
+    /* 层序遍历 */
+    func levelOrder() -> [Int] {
+        var res: [Int] = []
+        // 直接遍历数组
+        for i in 0 ..< size() {
+            if let val = val(i: i) {
+                res.append(val)
+            }
+        }
+        return res
+    }
+
+    /* 深度优先遍历 */
+    private func dfs(i: Int, order: String, res: inout [Int]) {
+        // 若为空位，则返回
+        guard let val = val(i: i) else {
+            return
+        }
+        // 前序遍历
+        if order == "pre" {
+            res.append(val)
+        }
+        dfs(i: left(i: i), order: order, res: &res)
+        // 中序遍历
+        if order == "in" {
+            res.append(val)
+        }
+        dfs(i: right(i: i), order: order, res: &res)
+        // 后序遍历
+        if order == "post" {
+            res.append(val)
+        }
+    }
+
+    /* 前序遍历 */
+    func preOrder() -> [Int] {
+        var res: [Int] = []
+        dfs(i: 0, order: "pre", res: &res)
+        return res
+    }
+
+    /* 中序遍历 */
+    func inOrder() -> [Int] {
+        var res: [Int] = []
+        dfs(i: 0, order: "in", res: &res)
+        return res
+    }
+
+    /* 后序遍历 */
+    func postOrder() -> [Int] {
+        var res: [Int] = []
+        dfs(i: 0, order: "post", res: &res)
+        return res
+    }
+}
+
    +
    +
    +
    array_binary_tree.js
    /* 数组表示下的二叉树类 */
+class ArrayBinaryTree {
+    #tree;
+
+    /* 构造方法 */
+    constructor(arr) {
+        this.#tree = arr;
+    }
+
+    /* 列表容量 */
+    size() {
+        return this.#tree.length;
+    }
+
+    /* 获取索引为 i 节点的值 */
+    val(i) {
+        // 若索引越界，则返回 null ，代表空位
+        if (i < 0 || i >= this.size()) return null;
+        return this.#tree[i];
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    left(i) {
+        return 2 * i + 1;
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    right(i) {
+        return 2 * i + 2;
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    parent(i) {
+        return Math.floor((i - 1) / 2); // 向下整除
+    }
+
+    /* 层序遍历 */
+    levelOrder() {
+        let res = [];
+        // 直接遍历数组
+        for (let i = 0; i < this.size(); i++) {
+            if (this.val(i) !== null) res.push(this.val(i));
+        }
+        return res;
+    }
+
+    /* 深度优先遍历 */
+    #dfs(i, order, res) {
+        // 若为空位，则返回
+        if (this.val(i) === null) return;
+        // 前序遍历
+        if (order === 'pre') res.push(this.val(i));
+        this.#dfs(this.left(i), order, res);
+        // 中序遍历
+        if (order === 'in') res.push(this.val(i));
+        this.#dfs(this.right(i), order, res);
+        // 后序遍历
+        if (order === 'post') res.push(this.val(i));
+    }
+
+    /* 前序遍历 */
+    preOrder() {
+        const res = [];
+        this.#dfs(0, 'pre', res);
+        return res;
+    }
+
+    /* 中序遍历 */
+    inOrder() {
+        const res = [];
+        this.#dfs(0, 'in', res);
+        return res;
+    }
+
+    /* 后序遍历 */
+    postOrder() {
+        const res = [];
+        this.#dfs(0, 'post', res);
+        return res;
+    }
+}
+
    +
    +
    +
    array_binary_tree.ts
    /* 数组表示下的二叉树类 */
+class ArrayBinaryTree {
+    #tree: (number | null)[];
+
+    /* 构造方法 */
+    constructor(arr: (number | null)[]) {
+        this.#tree = arr;
+    }
+
+    /* 列表容量 */
+    size(): number {
+        return this.#tree.length;
+    }
+
+    /* 获取索引为 i 节点的值 */
+    val(i: number): number | null {
+        // 若索引越界，则返回 null ，代表空位
+        if (i < 0 || i >= this.size()) return null;
+        return this.#tree[i];
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    left(i: number): number {
+        return 2 * i + 1;
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    right(i: number): number {
+        return 2 * i + 2;
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    parent(i: number): number {
+        return Math.floor((i - 1) / 2); // 向下整除
+    }
+
+    /* 层序遍历 */
+    levelOrder(): number[] {
+        let res = [];
+        // 直接遍历数组
+        for (let i = 0; i < this.size(); i++) {
+            if (this.val(i) !== null) res.push(this.val(i));
+        }
+        return res;
+    }
+
+    /* 深度优先遍历 */
+    #dfs(i: number, order: Order, res: (number | null)[]): void {
+        // 若为空位，则返回
+        if (this.val(i) === null) return;
+        // 前序遍历
+        if (order === 'pre') res.push(this.val(i));
+        this.#dfs(this.left(i), order, res);
+        // 中序遍历
+        if (order === 'in') res.push(this.val(i));
+        this.#dfs(this.right(i), order, res);
+        // 后序遍历
+        if (order === 'post') res.push(this.val(i));
+    }
+
+    /* 前序遍历 */
+    preOrder(): (number | null)[] {
+        const res = [];
+        this.#dfs(0, 'pre', res);
+        return res;
+    }
+
+    /* 中序遍历 */
+    inOrder(): (number | null)[] {
+        const res = [];
+        this.#dfs(0, 'in', res);
+        return res;
+    }
+
+    /* 后序遍历 */
+    postOrder(): (number | null)[] {
+        const res = [];
+        this.#dfs(0, 'post', res);
+        return res;
+    }
+}
+
    +
    +
    +
    array_binary_tree.dart
    /* 数组表示下的二叉树类 */
+class ArrayBinaryTree {
+  late List<int?> _tree;
+
+  /* 构造方法 */
+  ArrayBinaryTree(this._tree);
+
+  /* 列表容量 */
+  int size() {
+    return _tree.length;
+  }
+
+  /* 获取索引为 i 节点的值 */
+  int? val(int i) {
+    // 若索引越界，则返回 null ，代表空位
+    if (i < 0 || i >= size()) {
+      return null;
+    }
+    return _tree[i];
+  }
+
+  /* 获取索引为 i 节点的左子节点的索引 */
+  int? left(int i) {
+    return 2 * i + 1;
+  }
+
+  /* 获取索引为 i 节点的右子节点的索引 */
+  int? right(int i) {
+    return 2 * i + 2;
+  }
+
+  /* 获取索引为 i 节点的父节点的索引 */
+  int? parent(int i) {
+    return (i - 1) ~/ 2;
+  }
+
+  /* 层序遍历 */
+  List<int> levelOrder() {
+    List<int> res = [];
+    for (int i = 0; i < size(); i++) {
+      if (val(i) != null) {
+        res.add(val(i)!);
+      }
+    }
+    return res;
+  }
+
+  /* 深度优先遍历 */
+  void dfs(int i, String order, List<int?> res) {
+    // 若为空位，则返回
+    if (val(i) == null) {
+      return;
+    }
+    // 前序遍历
+    if (order == 'pre') {
+      res.add(val(i));
+    }
+    dfs(left(i)!, order, res);
+    // 中序遍历
+    if (order == 'in') {
+      res.add(val(i));
+    }
+    dfs(right(i)!, order, res);
+    // 后序遍历
+    if (order == 'post') {
+      res.add(val(i));
+    }
+  }
+
+  /* 前序遍历 */
+  List<int?> preOrder() {
+    List<int?> res = [];
+    dfs(0, 'pre', res);
+    return res;
+  }
+
+  /* 中序遍历 */
+  List<int?> inOrder() {
+    List<int?> res = [];
+    dfs(0, 'in', res);
+    return res;
+  }
+
+  /* 后序遍历 */
+  List<int?> postOrder() {
+    List<int?> res = [];
+    dfs(0, 'post', res);
+    return res;
+  }
+}
+
    +
    +
    +
    array_binary_tree.rs
    /* 数组表示下的二叉树类 */
+struct ArrayBinaryTree {
+    tree: Vec<Option<i32>>,
+}
+
+impl ArrayBinaryTree {
+    /* 构造方法 */
+    fn new(arr: Vec<Option<i32>>) -> Self {
+        Self { tree: arr }
+    }
+
+    /* 列表容量 */
+    fn size(&self) -> i32 {
+        self.tree.len() as i32
+    }
+
+    /* 获取索引为 i 节点的值 */
+    fn val(&self, i: i32) -> Option<i32> {
+        // 若索引越界，则返回 None ，代表空位
+        if i < 0 || i >= self.size() {
+            None
+        } else {
+            self.tree[i as usize]
+        }
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    fn left(&self, i: i32) -> i32 {
+        2 * i + 1
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    fn right(&self, i: i32) -> i32 {
+        2 * i + 2
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    fn parent(&self, i: i32) -> i32 {
+        (i - 1) / 2
+    }
+
+    /* 层序遍历 */
+    fn level_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        // 直接遍历数组
+        for i in 0..self.size() {
+            if let Some(val) = self.val(i) {
+                res.push(val)
+            }
+        }
+        res
+    }
+
+    /* 深度优先遍历 */
+    fn dfs(&self, i: i32, order: &str, res: &mut Vec<i32>) {
+        if self.val(i).is_none() {
+            return;
+        }
+        let val = self.val(i).unwrap();
+        // 前序遍历
+        if order == "pre" {
+            res.push(val);
+        }
+        self.dfs(self.left(i), order, res);
+        // 中序遍历
+        if order == "in" {
+            res.push(val);
+        }
+        self.dfs(self.right(i), order, res);
+        // 后序遍历
+        if order == "post" {
+            res.push(val);
+        }
+    }
+
+    /* 前序遍历 */
+    fn pre_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "pre", &mut res);
+        res
+    }
+
+    /* 中序遍历 */
+    fn in_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "in", &mut res);
+        res
+    }
+
+    /* 后序遍历 */
+    fn post_order(&self) -> Vec<i32> {
+        let mut res = vec![];
+        self.dfs(0, "post", &mut res);
+        res
+    }
+}
+
    +
    +
    +
    array_binary_tree.c
    /* 数组表示下的二叉树结构体 */
+typedef struct {
+    int *tree;
+    int size;
+} ArrayBinaryTree;
+
+/* 构造函数 */
+ArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {
+    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));
+    abt->tree = malloc(sizeof(int) * arrSize);
+    memcpy(abt->tree, arr, sizeof(int) * arrSize);
+    abt->size = arrSize;
+    return abt;
+}
+
+/* 析构函数 */
+void delArrayBinaryTree(ArrayBinaryTree *abt) {
+    free(abt->tree);
+    free(abt);
+}
+
+/* 列表容量 */
+int size(ArrayBinaryTree *abt) {
+    return abt->size;
+}
+
+/* 获取索引为 i 节点的值 */
+int val(ArrayBinaryTree *abt, int i) {
+    // 若索引越界，则返回 INT_MAX ，代表空位
+    if (i < 0 || i >= size(abt))
+        return INT_MAX;
+    return abt->tree[i];
+}
+
+/* 层序遍历 */
+int *levelOrder(ArrayBinaryTree *abt, int *returnSize) {
+    int *res = (int *)malloc(sizeof(int) * size(abt));
+    int index = 0;
+    // 直接遍历数组
+    for (int i = 0; i < size(abt); i++) {
+        if (val(abt, i) != INT_MAX)
+            res[index++] = val(abt, i);
+    }
+    *returnSize = index;
+    return res;
+}
+
+/* 深度优先遍历 */
+void dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {
+    // 若为空位，则返回
+    if (val(abt, i) == INT_MAX)
+        return;
+    // 前序遍历
+    if (strcmp(order, "pre") == 0)
+        res[(*index)++] = val(abt, i);
+    dfs(abt, left(i), order, res, index);
+    // 中序遍历
+    if (strcmp(order, "in") == 0)
+        res[(*index)++] = val(abt, i);
+    dfs(abt, right(i), order, res, index);
+    // 后序遍历
+    if (strcmp(order, "post") == 0)
+        res[(*index)++] = val(abt, i);
+}
+
+/* 前序遍历 */
+int *preOrder(ArrayBinaryTree *abt, int *returnSize) {
+    int *res = (int *)malloc(sizeof(int) * size(abt));
+    int index = 0;
+    dfs(abt, 0, "pre", res, &index);
+    *returnSize = index;
+    return res;
+}
+
+/* 中序遍历 */
+int *inOrder(ArrayBinaryTree *abt, int *returnSize) {
+    int *res = (int *)malloc(sizeof(int) * size(abt));
+    int index = 0;
+    dfs(abt, 0, "in", res, &index);
+    *returnSize = index;
+    return res;
+}
+
+/* 后序遍历 */
+int *postOrder(ArrayBinaryTree *abt, int *returnSize) {
+    int *res = (int *)malloc(sizeof(int) * size(abt));
+    int index = 0;
+    dfs(abt, 0, "post", res, &index);
+    *returnSize = index;
+    return res;
+}
+
    +
    +
    +
    array_binary_tree.kt
    /* 数组表示下的二叉树类 */
+class ArrayBinaryTree(val tree: List<Int?>) {
+    /* 列表容量 */
+    fun size(): Int {
+        return tree.size
+    }
+
+    /* 获取索引为 i 节点的值 */
+    fun value(i: Int): Int? {
+        // 若索引越界，则返回 null ，代表空位
+        if (i < 0 || i >= size()) return null
+        return tree[i]
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    fun left(i: Int): Int {
+        return 2 * i + 1
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    fun right(i: Int): Int {
+        return 2 * i + 2
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    fun parent(i: Int): Int {
+        return (i - 1) / 2
+    }
+
+    /* 层序遍历 */
+    fun levelOrder(): List<Int?> {
+        val res = ArrayList<Int?>()
+        // 直接遍历数组
+        for (i in 0..<size()) {
+            if (value(i) != null) res.add(value(i))
+        }
+        return res
+    }
+
+    /* 深度优先遍历 */
+    fun dfs(i: Int, order: String, res: MutableList<Int?>) {
+        // 若为空位，则返回
+        if (value(i) == null) return
+        // 前序遍历
+        if ("pre" == order) res.add(value(i))
+        dfs(left(i), order, res)
+        // 中序遍历
+        if ("in" == order) res.add(value(i))
+        dfs(right(i), order, res)
+        // 后序遍历
+        if ("post" == order) res.add(value(i))
+    }
+
+    /* 前序遍历 */
+    fun preOrder(): List<Int?> {
+        val res = ArrayList<Int?>()
+        dfs(0, "pre", res)
+        return res
+    }
+
+    /* 中序遍历 */
+    fun inOrder(): List<Int?> {
+        val res = ArrayList<Int?>()
+        dfs(0, "in", res)
+        return res
+    }
+
+    /* 后序遍历 */
+    fun postOrder(): List<Int?> {
+        val res = ArrayList<Int?>()
+        dfs(0, "post", res)
+        return res
+    }
+}
+
    +
    +
    +
    array_binary_tree.rb
    [class]{ArrayBinaryTree}-[func]{}
+
    +
    +
    +
    array_binary_tree.zig
    [class]{ArrayBinaryTree}-[func]{}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    7.3.3   Advantages and limitations

    +

    The array representation of binary trees has the following advantages:

    +
      +
    • Arrays are stored in contiguous memory spaces, which is cache-friendly and allows for faster access and traversal.
      • +
    • It does not require storing pointers, which saves space.
      • +
    • It allows random access to nodes.
      • +
    +

    However, the array representation also has some limitations:

    +
      +
    • Array storage requires contiguous memory space, so it is not suitable for storing trees with a large amount of data.
      • +
    • Adding or deleting nodes requires array insertion and deletion operations, which are less efficient.
      • +
    • When there are many None values in the binary tree, the proportion of node data contained in the array is low, leading to lower space utilization.
      • +
    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_tree/avl_tree.assets/avltree_degradation_from_inserting_node.png b/en/chapter_tree/avl_tree.assets/avltree_degradation_from_inserting_node.png new file mode 100644 index 0000000000000000000000000000000000000000..00586167c58f11b6ba9762c9519cd62c069aabae GIT binary patch literal 14784 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 F{}+6+$6EjZ literal 0 HcmV?d00001 diff --git a/en/chapter_tree/avl_tree.assets/avltree_degradation_from_removing_node.png b/en/chapter_tree/avl_tree.assets/avltree_degradation_from_removing_node.png new file mode 100644 index 0000000000000000000000000000000000000000..dc773daa1a988c966437e8740651337e6ef8044c GIT binary patch literal 15441 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 E1-^>fZU6uP literal 0 HcmV?d00001 diff --git a/en/chapter_tree/avl_tree.assets/avltree_left_right_rotate.png b/en/chapter_tree/avl_tree.assets/avltree_left_right_rotate.png new file mode 100644 index 0000000000000000000000000000000000000000..3685ee4753a4640d7fa38064474aa2acaa65b190 GIT binary patch literal 21615 zcmbTdWmFu`(>A<<69^6o?jGFT-CcqwIKe$(ad&rjcL}ltO>np1?(X)I-~aypp7YF? zovN;@>ZYJOJ*VotBzC+Nz&_`%V_T;sF z``JV8_q^fU=hdmPy@$1v)tBez)z#I@%gf&0-jkD)hlhu|`@5y3rGbHg@bK`wyu7EU zr^?F8!^6X|v9Z$9(%-*-CnhEi4-ZdHPNt-!OixeW76#PU*GET3cXxL~Ads5cn#|11 zjrH}PKYymBrInPFM6`t;E23^}Y$z)$A0HntFE7W%#~T-*IBfaNl0gIMtx8t{xZ|`2G8L9UUDxIl0-{+1=gUot>SvwYBG+ z<@x#f*v{BvRji(#p2o&Tx%7$DU#YjZw{{ZSP*cd$~My zs+uh*DDbQIy-Kn-FZfzNvT_G4EgC8`Gc(gl)7(1UoSU1Y4Ih1)``tR*y4zKq)1Q5v z=O-m4b!td?c5|kaH}lY2b(89Rb$@kqb@Y6GND?%1U!Qze5?noVy4#d@6=ry%N3wJA z;M%yJ-~V^F73V;wqtY>1kzBFlq88%j+i5&N#!vhBdLjrKLfuhR~+Y$90W8i>xC$@U^sl6qLT+Fyg? zq(TGy)>`Dx`+oQEvYJvI{-5NFY5Bd&kW!ud+R<_fnsyr7*;*!Gy4_Ef=-Jw^pR+<% zxqO%}MXQ!5*P*}YtQ-wfJfY=+l%$wCJyfUw&!_l|w@;I4QkpE6j_R7}(wW6WIFQ0s zSMpD`8g`L9C>Hl~C7JO!l6 z%ueaT#8P|xSAv6Q@&=jQ#QhxOs4~%_5tV<=EX;Uieug|!5*^-EyE;u@N~B}8?fD44 zKQ2(qU~iBAjeYGsK^5p(G?dfx?cIo(qlAFrn~xuQ-szchLJkMZay~j7nN-)qa>~ zr$xMIXkM1Q%zym$^1WE%2OD_)<${W?Iyc%Y=VkN1mOL$D4*uHX$o~*drPcHMoh7^B zoU~Vwg`FEsZ7lymsu{2Ietl5@|CiZp_D`=S48CRX8;PCtjz=#`RwOX@OHFuI&!c~p zpN8ERq1siID^pRGhOh$@Ijz{v&;5V$Xd=R7>EKvcm60L}>?z<}V#Tq10nKaXu+sZX zcpCApdp=khSUKQ7b8wyT3nM~H^l5!cxNvEaC1|0p5pqAX-j*yzu|fr z;c0!5B;Ms$#8x8d9)yjP_L@HJ%BH>1MIsRUi+y2@zw7ofhlwbKXS zbfv)O#holPGBEM}P1E7JB59qyc8D=a?WcVh=>y$HZ*p;=7KM_rk)Uz0Ueh6A6}?21 zZFP!98CvS?(oKXKo`LHt7klK5p!iN(HnIRbdVC1W$M1x+JOq48tNd*oGzCO0%VKp6 z&Rc$8w_4hj+Te|D)K>7ORqPqb>|i7U$%0g7OSmx><^o!pf!Zi7SwigWq?{ag%_9n= zWd4O<=Gn4-6UnV>T)4HGls{Cr0ER))XBaN>4PKHeW%WNbwjTzYQ0RpjhCVGVCjrWd z<}P7flKA#kIb}q6`S_+QSz*v@G%gRN#6x-=rm4OW0+;@QbVXom>WL+(MG zW0yp>p<++(Q#Kn!dt@o@jR(?Xtl9jmKrSUD$sF1i6wjX^=9$EeyxDfNR3^*oWh{yBiwvRv zrTp`4Y=gBmS`4sPQVUn!x;EUBDo45|y{fhL=e!aJ^^iW8RW@ACKGaT6S9fJfw92Tz ziEIOuvTI8x>vIyq0J=~>K=zqh zw4p$6ZEc-b4sC}XvwYfz_ol%$_yCM9i_#qR^Gk|SGeEa&3Ip44oz4HGZlURMdgw>o^2^+qY8$&kyze@2}Plb^7}w(bab2d z=&}Lt1&)>kuY#}m%=rt`%TG!;ICsT(syG?%z6d???LLhTV=+&A%99EQhK`1CT2)F{ zo7c7i@)cn3(w?+Z;eUv;{gLaoj~f>mpTS!3$ySg{Yi?}Mu_fUE3O?+#%FL`|a#D2m z1pV3lK=IRdmj?yJkL=gcfu3X0k^%d9V@Z}r03fqFcx4lh4w8>dK7Sv!c1@0sUsc>N zuc~590SndNEf%BDxR@jrf4Ma8Im)O-N@a!bSVJ@Hb0kq? zbg#hFAt559!V2v~jH4e0R`JHcMW0PazBB!&@eg`NJqwPwI~DgkVeygfcfpb^ZWvQ+Q~*gZd;CrL8eM#PZa0UTA!lO#iwC`bRP4SB zlQ1?S*r6Z-j}D+?!%zZb(M2HF`~}iLh>>H>tcTg-K#zx}CQA-esi2TWjRSd{+A`DU z*TZah*Zl`Jti}9?!(EsRJ1MFsHl5Nz&Xe!xv!hpG<3?ll6;vRe+A(E_XJo9-?7y5t zjCi87X-o<5)_25=1dmX3K<`39XczJx9)z)#K}N|SERCfgwUfaju%hGr=UkSf-*7-w z4;Zl#n7jM_9{lP60GRrlA*Ozp>+#7?CfRR`?1VG1q_O)PVwQ_=Y7*?|^&ca~F$ong zjDqB8V6;P#0stTAG)?p&v*4a&@m}^lZLyjCh&m!?=-*y|*;EoB8-f3w;lg_4WGmpC zCpR(VJaiFeOi+N;`S9csGpoK?CgNL;9B0@kxq+)K*|+{cGb#z;{T5I(5E7<>IS`C4 zCJNcZO|UMT3emR7DvCYdNYj)}+zSMm)lvz^CwvUgNBZDNY_qA?r)jqwr@&`tAN{!l z`H$Rths)(}Kv2f^GxI5UTpkk5pAq~wFM3}+@a38>Fl$+DFmq|=<&twm#`TNL;zj_~ z5>Pf8v4#K_&jgj3cq4MWlhq@fAjIMhy-_9@YG5NvN(G~>fT*f)R*8)Uu!&1)1&0np7B% z@GGc-3d6=CLps8l5*pa}zdTRnZ61mJ)-Gdat_NUSPMBNI2=&Nct`aTJJ^caHVa`i> zkZ5&=3#OHxWqO;Pak%fDiyL--EXk#Lg^SD$Az>d!5rLz|w55Nv0g3Q9C3)qCWQm*C=^VxB>$*#Ir(brNRwsqai z*dQT~4Og%Z!ICm4sRr+9$R!UbG?~%DI~UQohYmXVJ5&|P%6MKntu#q9B*SI3eQ!Vo zVmP6!3)5AA_cj(5^G;HnV5#iWHinZ4#@d+uYXBI1KqEis_jJ-zBLc>dn9LXdEq)JG zLQ~4MJ!#QsQxrCgs?OO9S$yCp#c6LHzquQj7K@D}6fHA03-{aW$J;?rxnwLFYeyDZ zzYrcKh+_4F^d6wcS$YgH+LTRF7rDlY%sN^VeMC0x$?7!zXFJA$gBT|mE?Z_E{4Dkt z`Jt<&ynf2w+EdomZ+h4m4b%`2gkIgqBR+yXIY=vIS~#2$;+tWXj#SfIksO?1we=?? zCDYS(r9#k2gwsFJ(f5a+rkD`=VZwkg+0-HSiV+7pSxJ=+c}dL zxPv(oCXrxY;JoIWKemsAD@qpa>VK6tNFTBx=(+NrE;aqH>?>8({vC_oEvSU`_<_I`oh$=OcJ~QeA__($BdJ(&eEC~#l38b(@uKbX|30lS-+isb#kz4H+$IILW8F3lPO}3r%ivY%!XR-@!xABbTjzXT}pI8n^}n#q2%*S7ncb~&g}ln!;oE|F&>Ww->c($x*fJw=@y zYiv;sA>fUbrs=6lQ;BzJm_;ACS$R>uV*}O=;Df$jo^SP^ za86CU5efyVr##AY~%2SY>nFsW-S$6z6#%j2vRmR(!S$*#7ml7ph{*$ z&wc98{PfQU;%t%d-=pdX#cOF1&#@a9}lU$ zs>Z$Lm|B18w|Q)7r;9qo|DZFk4E>~1x5b<42K444^*R|3gkIpW(MR}FbuVH?r8iV= z`*Nza4wq#dzPqy$z4>c=m(n!$(sr8PSZag?vq|;Yk}yX}gP9QbsyRuiB~+2c$MAEA|N7-`HPZN&RVrq)vnQZ4B}RZLMRcu?!c~p-Bg%S&ue5pX1 z=qwh0BJmg0`@chxvPKthv29vdNxfF=1EAl5U$V%$A_s zW+EnKq{eg{$)JJ8&{al;BFPtM4#9XB%Tuq$yGI&TA->E6J#eHp(j@p~bRoDT2!5HB zktAdYeiqjGb0qUi)|S>^$ZuRZlMH-~wqdmq+UldaQU!E$He%S6YL^Ngvc9bhE4q#; zjT&^`AMg7vb-icmHDEj@KU?&k|8o%^e)9LJC)t5E5HFu)=jrztlb=b5)6L(WaBAW` zhlZrz=~wz_UX2Y((2Qqxg&yV%A&m9E#^ofEr_gZCKKQ4r+P$n%#t?Op&>`I!ZJvWBdz;YmLZ^gE zh=67V#Tt9?YQn3$#27V*&rQvgVHh?+JrqkDYr+Oh`23~JTm{P{8dn_Vf#;=;E><8M zfgi*b+!-OKEZj9VVfqe;y!(n93zo6?65!ESoxhkRp@Mbn%U?T(!wX{TT|F%(nc5QQ zUwMs&k~`EtnBE(IBB>zuUz11F40zQO!=dEiI#|88`?L5%Aoj_Qi83KLAg9*=JP30o zw88XfDQr)MK>suggT>{A?0*3j@$}8HpLhjf4@V(sGtbvjf5Z|Sk~66WZX*QP_n5|j zUIy|!dr@jOlN}~f#I?{kF~%)QcGe8ZS&P@=(n1lc1FFgco%5bFmY$nENq zxJG!(!t&fe2(~z8XSMPx*kV#-7RmK|aBDX(&G_AXxa5(;x)kWwCR0Cg;A^Mo45{4> z)sLqL|0{n9tR*+}9CLlF3SYX%~D8X!-XH$$%O6qx3=kFxf*VKa-}jid30 z?gn!6$dX63o5R1A#QLAgrJ?WUTzXOJZV^qG@vUe|C37f|=TNd9p8aagnDA-`-V5=c zr}#7?rp(Z7eD&enCQeGX`b{NgH0a7#^^A$7Dudy5j0ZQ|MaN&EaTt=`f%s-zFzZk8 z(?;OB#UL0vpu?<}NQ{5Sknw&EPx&v27Z>EK8cLz70*sxSCpcfV>SttFL$iW`x=A(S zJOCAckgmEJvH@o~4v6b*`lhCBGj;gkQJ|LTA8D2V8-QgI`1Dsu`ZEjMWp&oHb6gci z)BbhKr{cyhUcW;GqTYdb3$jPt@!vu?LaK$KoICOyTjAtaP%<|hne1w)2=En4YN&&i{qP0fEtp!U04C9 zlFEE>vINPk3vf=WSaFHXB%1uk*|rkod1GfSpvn$B=^**iFjNUnZz$hEYvj2+(_r>QG_>(%K`3a)=7Gp%}#gPTVnvEw= z=lG{Gm~N3wK|aw8`Nr$gJsW8}PKz98HBmEkH^9~i59isU0x3d!`z)52aIpa)+!zVyBZ=EUCT>;0d73s#i z7sd#kEvo}QYzNHz1;|aAxF5vmJEm#}#PiYgjtv>24l4;>`t4fXTMrO_o8EP~pR{?A(pSUM{B!Y+; zkxVL#yo7Yd7kI?nylVljV08NU!WSd2hA#4M*D&AD@`; zYFyQCPjue-OLR~4wi3wZZcwoT9EsahP$y@LXCYW0lNeHjPB-&P5Xti8)wEuUh7HyY zCI3^=p6|cv7yhe$Lv4EF{Y`Z6Kb+HNQ(3;a{jX7RKZ<*!zv%&PRu$Frt$WoZ1_xuB zz{0Ee;*(k$oc{s0C?0X(j3(wW=1+>UEdk5cvC3S#%YO0~p(ZJlU{3vED=+`dkk~L! z$7WjuyrX*rV$dS(9oso!TPyD#qAQzJm19mJL(4&K3)SWO-NEXq${ShiqkCy|+@~HW z(UI`%0?G%_C$Z2eVq7zND~zjYN!eBt0NFe_Hy-GdQM}N5j+Ry!tV7>p?iYhvcHNIM zE^RaaO`=e(Ltk4$dwZwztwzcmApxw?>A7-6!*MXYm!Rr&0z}XSdU*6T$}th629^d^ z%B;Lyg))v)1Nms1ZvHZ6L_-#ea)`>^lIpNdnbSoH^F3cTx!Bdv9Z?(33pFJX@`3|7 zJPMKrCJze1@{NqrVNleq6yeAN-@4D3GDqOmL>s~GrN(XNlPZh~!4JP1>omJIjz*S10tSCq|ntys9SVhAyiUM=4Rgi=!0|$ zB~Yw{ev7y@_UdOWOsp=fh=d#L@2`Qy7Kq;TjFj`6{~YC^Amr-4h-gs04vruwt0+LF zUn=dqHI#smZ$sZ3p9RN1lY6z5mQfkeymDeYPWd!FKV8Ut!O{2ssOJ#CZ`7;|gLX$7 z*Sk7DSESHPJxrlS>h-YjbbP3jsAErfFtcRXoB@U%R9H=oxRa2N%xge0Q5u9djOgw# zlWVWEKGdU|F-XYp5x%)%!#`izW41-puDpC%l@M=)ka9hL#omZ!sf3BZ*ifn>+40kd zT*Miux>l){F5!#a4Ewd}@U|sFj76V9uU9EU=!Fp-rwpl1Ld=nf|guv`j=7ly(!$)-d-uzv_tyd?fGCh*BWJWqc&O~Uou zi*9<_5@Iz@mtUf4+^1%|uI1kXAsfV|rL#!A@XkiQ`2GSW{k@Z%&?Z33)C6zFB*clp zGs?ru+J)8E zM1vtx>pf#6%8&05ts{1jJ(6q!^f14fZF{%q2B(;YIFVp(6%i9iw8O^va7@zgOh@O` z>l`kfgdAbVMuwCdrFhQQg2*P7Cbc8D!F3{bFWJW-o5m?opW<|`d-nF!=THAxN`%Dc zqAY+C1fZ@-WTSycG3l?Sf_ckM-sPlTJFM{McxFaa8_p!`Y{2s;c9Jl}1-9goki(BL zz8oRp_`**@SBtdBW@Gww)d!;@1h4@HMd{=2B!gKl6`~pNsoXv3K>?gwlkqb@2`Yn* zQipnJQ8AwiuQ(BzWTwe+xEd|JTGYJS!@xNx~~klas5m&Yn)uV^h$vGT(rR z;NmQAPEAS#5GA+%$w~JyIDMq&%W5J!FhX+vFfs5%vjz*ZA=JrU=fk|OJ8B4413O(5 z=Lf0WzuZ&_acLb#HZHh+nJGC68U91V>b+{h1v!N(wROL>5x4tUaucSHzL>`!>hdCT z3hS8?Zg36`WAq*iTZkFVPle85C3wfDnhMhvF6PVB_%1fRMM>3((!LQ1*2E!kT{yhx z;Bi@QD;+siwjuz_(#{Ym_@PYqk9A)^Fp>#dklY`Q^pcNkgTX`TQhz#_rdV%aH_)vQ=z&SJ0hpD-VTav(cf^xPdk%eWPfwtCr^ef#K#-eL_alNw~LfIpgX{! zd8R~hV}_i(HL9iwd<3PH*nZehRPO2ZI+p`=$y=hJE&uc9?A3s3lELYK8dcT8L74r3 zLd)Hn9OoyX3(ums)V{)WlP-L_VQt#J_(fJ}mC?H%SvEA@i?(nfpEM_Qv6rWXC{@hR zsW4nGM2a-Cqw3HgP<3O=K(_40)4cq<7?i*9x0C(bAavVxCt+u1hGoeC$X8LAV%B_# z4uViw@llO-U;pR~wj-PMYw@mV2Xboy2Us|PK1=iqqW0(wji+CWyv|Vyj~^DkQ{$7g zdSL#z+&Ulz&g0e5AP`bUC_s(9wil7LVQdk1*VLQG(a58oKz_~1OhTQm9*tfP0`^s_ zADoxF2dI57cR-J~J=}m`gDTf$v1%nhLT(8fN=8HC+D2)oHIN17?wY)NBRZ0pEelld z*wNrD!D|l*^?cB4OLqRXN574QoN_`e9unOciC(Z`C6Lba-9JR_+fiBs-IoNxBoN#TRv~PoVfqtD} z-rLs4g?i7xn=RGXy_SUlGN(rleSfsc3;lj`{;{cUH|8DG?c^JgKMMCwvT9q$1*89y z$?4zE`5}4CKfI68Rlb@NvmLTgP1xkIyvHD>p+h$;3DhkKbQL6{k)Bqp#SpKMP=-OS z9q<1`V)89N@zvMp3w_dPN4<=zc?93#N~rnGk1mtB3SVKt6Q*02(ZOhix$eduq8$+s zZGE6eL>_2*H2vM%>X+Rt^4ar+j-U#4OuSG+T2XOrIf?cU8`I(EY1EFr@GgLQ>Z1v0 z`m)_ie5!ki?YP~I4dh*T10c3IQTrdH(0ucwwzo|zFZWenvdk&gWm^kCDBxSQe={;W zRy*p%(4{QIQ`Nmw)OklD_^NC$lvs9Ts{V}N4P#8GuXmNt^y6Ufdr%9&a78oRuo3g_ zDMAoq<@v?i9c8D$)93R1Ieq(EDfvH~!c@Hjrn0w98R{sMjRUbDOwck6S-H}g=>wb6Mkq4A2OZSLa+F;xuc{HLU6@hPdoER6KjqSM%Q zz}kt*^_Y1spw#=|<^qy`TJm3*-*#a-n(r9|nouHL?DxW%;=BHGR?90Yjk!v;Jm%?_ zK2}$+X8p}YC8hpO!=W(thok0dzU|}T+BmKuRd}k`pq-hl&Y9z1Y+rtNq>MuKTfH?n4xzn3`=HH z$6>{hZ^PRDmu)O@cN@Lb@@YZb3EVDVF3XpX3t(CiPggq-(trIrrgPP&lxU0{zdcAK zjritgyYK4}+$#5_AZR~l2s=7gbuW4u)Y~}|ZhDRvqHQsri&8`b4 zl9u@oRdlcxAaM1*ci)_dd7%al{PZQ{i=kKPu z)D}f%$vsFY<==y_aMG*%*=81w11S!>X^F$z-|LjSGRccFlxl1o)a!MoYbXmIjXXHo_>z;7`MaEvz-7&^!%ST`j zPZ>D#Qi!5??RzWDm%gIIwc%P+HtbD(6Cy3P!_KU5m^AV~KIc~?!YsAdDAn`hwoTqz zw|#~#-dNP6JM&QQ2b@dE9Uy1~eY?y3tz-%Fvn*P;>2_<586LK%ZmyAz;b6sxwJ;S{ z@%wL_0_8uu2O}8K)*xm6OU!!_Tvx(>n(0|AkfJ*55?jqxx#FX097z(1jtx8gBK zm;H7`EXmiBJ14-ufh>RUtlO9{r6CNj5^rQ-`#7OtYmEc?hJjOR74yPSJf7JrbZI|^ z*Jl=iC0fVn12esZY?xP*Xbh8B%)3)Fd$W9tyhq=3Gn zEv2z5?o!*auzj+@D||pm@n8Ek}aY+r)R7kTXmq=!Zcc>dHcm)(j?`@a!%o zdYsF9eqW!$oGq=hyxLY}BRGW5yJ`XBzPi5iAe%%6hRQ#E8+8cxtiH1ji7)M~Lh5om zFNz+YuxRkR*iD62-DD}R6Bof5PB~(4_Ob8Y>~o*O?j2hR6k#tto)LF^D>r7Yc1tS` zXahco`1++z7d1ezyTOiQ*(_N>Fy0@L2WnW6iVLl?Z+5;^w883j_vk%v}{9 z;|`S4j(6i2ISw;bk~MTSsAi?t8V>s^8vOqw*LeC1$$kC& z;0pJIam4OZV`Br|+`baAUrF^Lsz?rWwrDTwM<#JIrvk-UdIy_(DlJma9UqHCY3uE9 zhg*@(Feo`Njl%~*gO86B)>v>fAEFwTNl70ns;XK?h0ljnIIpAq$8gO(s(wAoX^dx- z+b!x=>!ca4-t%XdN7n7%Z=Jp>wDp$H3!-ZQU5MS0dou^k%NP)_Sh+^-wboo0vEP%U zkxC7aused87{BWyD~rEq*teiNb8|Sb=3mGwqpn>fGe>!iRpEBg@tg_r|)w@Ho-3#AyTDX<`~@d5WT2F(4WXrc`vFKWx(`|HV z=ndXTH)8!*p0OP_i*TTNY9}M7>b})g8kbH;DKiRrmP68dEfpZCB4yw@r`k88K?)et ze=h#a6TS?=%~$yPy`CZQHBYNt^#0pBPqDRxTZjN{M{fjyWsdv-b@QWH4AOMz=n!Pa zkkHqRdzNFQPTfsz%PO$XAhJ9iXf23Xt5n(>^$R;!u>58BuGoTBfOT};tS1%e^*aU| zV263u1rKcoN$WkBGitZ1#S<^ahig7W2?z&@zqnnc;hTI#*Q^G;ql4-1LV%R>3(d|l z%WZev&HNeip<}oZ2@wF;o#!EX;(SdYEk)rLNm@GSdxy^a6mG;yXf0Put5M=q>`<;5 zh~#oI-456AL;jf{5%(8m#jbV&+?<~a;3^tYzXnKIdiiEsFAj(>tW*aOcrjC!@qj+k z%pgij!#w$n2?aS~uuf2uyr9=0y@M=W5FU~}WNza#1`K`IaK|=c-ZnRm*pmW)$<}-f zA@RvZ&)RarFcqR;qkhxK@8+>?4Hg7tGwu<>yAmV2ByejiQ{0_GPhZ0!DDcn(O1y=! z8X&*V`s4uhHztA_aj1?oV7M9ZY8J~4I6&CL0`P$PKgL_iZm>-JUG(Jv$kGsEPQjfG z3xKFmwRxH0p{thhTJ+dJFOU(+>%Gb)&bX7jVRgKj-9D5-IHm@y1qb}0jj=3vBX6K2 zegs8;ctmr2Z^ZaMgG7YycK)!nz00MfID#I-XAfV*5~?KrlLTs)z}E_-#?C1PX7h+J zZAF8dLj`S)MJwNf6@^)S8k|0~0v|Q#$FJ1Oe>ubG43%c;%e z0P2l;^hp>1)J=x8gA$ZM`Y;G%pF?V40-nr(qdzKa|H2WdR*w7Pzrs~`C|#BCfi5u4 z-m6DqGeEoiR8>mptapeeg0(>j6&J+T4_1LY`ns^%5sVo{`9+jQ-Cd{yAcDvsuc=;~ zHQK!BSfW6|b_GY~*V>|L&AUDZbOz}D->VqsZaLv8Qv30Yv#&TtvcR$_ee&It$tVAH zj%z!&CSQ#k)5uf?5G+jvC}S}Tl(EvqS-e?|!c+$c{sjI07#-nv=e@a16C&U>wy_%} z#^>V$%Vfc+0)am<7Qs`41dGAq2`(yRQkKnl!qB{aXpxSCH^o^CLbAWTAwJ5Kv%plr z5?;NYGeDRqQKrPf5H7C-kcH%GJYy@U#d zCYCtYHJAliC5%==AFKED*Xd;YBbDN&SzPjN31$ZPYlfNM+IH68$CIG~)VH0|IEJXL zOhkd+DfbQxqaa0WGBXz5ux1gYpKm-^`t49-&~qLzNCGu@8_Hlv(&IuX$51qYlj+;R zP+siv52o}?>4-5rtFX1VA9M7R8U*;)M<+jTtxPXc`h+pBte#ePfE`J`vAn~Ds%TR14xhV%s5sbvMR~;2BO!^g5fo;Sx z(T)%3jnXv#xqZR~QOvTq{zlKC1T{F4vu~M@TUBV_ketV6)ha?d zNjOn9#-e6R>1ctDuN`PFYRd?W#G2RRWys_Iu-1@X@_tl4YY2|~VeraNx3MAZhx6-f z45Jobi(i=sAd09TA>fIrg@q6C*lTwVn_rFH|6b9)9Wx1OBoHbn6$}v}Cb$*D;l#?h zm)ygRsJ-^$hJR@X%!rkL5?&g($VRmPXlhOfl-(?RJ=NErp|mUoL^iCody+*I9~_o% z!&oTRR{#d`a!`FlFMBw&H-m*yMj?XpDv-py#1Y>gBdJ16!v9BB9XBT!quc_xGEW^u z{I*q>LM$V4Tw=Llpd4BGD?&vUtwtm_rVFPq>c&WIRFt;UQ!${r(Z#u8VjsU79uwGq zA2{cTRMXVi3G07-9WR>8%o!w_OQla&XNd{5wMl#T!G>PAp5@Hr`QtumP1{=vOEWXq zNQ?2Y(sj7pRW~QkvCqFFPFASMi+?V;0Gp_84HvR)-~mems-=x&{8pC}(r632{>Jm>u`=`h?t2hAds7PN#IiBnJ8s~j^=8OH9bnfX2#50&ogCig$+-^hM z4%pwvhg=Da8Xy5oufvR|K)AoH2Xx*YQ49BwKYx&IF)FxO}V!>#ORNA0^sx-z5OzkP9Ov@b{x?3#b)|=Z6Eo8j1OK zU}XE~GEl*!tjm!C1rP1z5be>LlqVy=zSW3xqKr3RVi{qj1!~d&@Oo5lg^yczE{{bH z)oQqjf?8ObYcLWwMYoZ32Px@C_hMd(@pPcN*|D8Xx#TbY143Rst zPP`7~zk&dMejXp`gOAzbbnbqx%o|*y&r+}iwaX=8DRtHRFl@gS1~mmnnrjG;{A!av4C6NDMCFaC@J)r>Qcm;oq-VfY1c=Fu6a1JVV}(g<^pxWR&;KWgDx zHyt1+I%h(gjtiRJMZ*9!Esb* z{`q@qlTZGD&!OUehW2FNhxcL((YkQv{(96FQzschWo?P)Im5)06thF zUz24$eeh8&nHq?ce|xu-mDDhaqNN{(_#NoT;jq`&NuBRe`Xpf zB^6Y*wz9AVu4PgbSoW4H6w4O5z*wrcFS2;*!O8II(+V-XELoDLHD$QIH3!9K5RSR< z4i?1YT=|&sScu7|fkaI+AhxqsM}Y5@O9X?^E)r7`_z@cy(;PP&*g}MZW7GwgRkpEe zs27eeD-THW@!D%lcbl4>RLQjNN_*2m9A}ei>H{tvtbkRL;O3ZyUt%VCTu-&37aJ z;%=>PWh@3zE44?~!@<_p;)Kx7vmYjx8J}k?io`QpnFD3<$30(Fv=hb3k!$Gd+vhwb zjvQs)UMF*_n)#m3l18(WFqdg*BDMcCYX(TwHRkak_|W75U6F({k%tGBWx$?&jY(#I z9D7?mhZ@kQyT(x^2gXN1w;!@8`mRXm#ggYn92Nm+6Um9}rmWwhj0*=#V*LrtDsire08wUgA_STjxb8!byq8lMI{Dg3ee#Rl56_KxZ9 z%9R{i+LMfBAJF@?K8`1pVhRS<5w5OOGqs~~XFM`}H=0EnC(3QKWZ2fF|3$v48~R0< z7995w#Pc%sp|;{l@g!FulI!9@N&Pzf&mV93wWm+a^CA$;p+B7{pVVPg6Sbi}uiv#( zXWk`p?j^> za;)*Vr+(r};Q>9B*J4#_yeQyAGKR1nvV5tk5>XGHTpmnoww8=j_x~tqoub(lToVvT<(KaIW?c*w1 zTs_1aJ%!K5tB(NzRp^G8|_GJY$TJw zikYcwqBDQ7vUYw|ZNFm%$K@ITOXCDHiiy~ilFrfYI z5Wvfqbl{t2=we^OkwDj~eOzr%yPq;40nT3*%;+qHlcontKKx_fkaen)NKlnpWdgU8m zR^Un}u7@_>Zw9JML*_kb)V66fkJbbxaPVfJsN>&Mo z{34+C7ZWN8`J~ECD2y9jxKofFu`5%W0gFd>n7WZA!)9~nS%I39KA`Fp^J=}hI+@vd z0OwwrVIF2pHL|Gyc$DsT27KmEN{jDgQG5&)@CE$d=7;9+eU*JYPyWfzKGXfDCo%!w z3LjZH7`;?+(TlzB1R=+qbzV(M&85jz`4c;jH-uLlUfKBc<0@u)|4EEK9N-h@P&Vzb zMz6RhAm2jJ@4FF>Lke$%vyuw0oNzGKh+6^v*+VRwv7-Zq8cOYN7hy7J&(=-0p+a4Kdl6Yx(qe&VU zq*$2@|N8E2VEZD)8H=qaiS*J!Og}nHmUf7V>U&1Ue`(l0?KOA3eX4+Y2MQ>Ft3j{# z2)9coJAhaIACh2zVaI}xY9C-FaaWc?Xum>f#3wwS2+XLN_1Tb<3fx9}i!$glzcbb9 zW)A4758aAUbko%4Z)kYS)MfE*;02ZY6yt223Nl~@clH+zSB&7p;toS0JIyELSqZew zO2%J9rr>E>@jUb6EPp2tKrnSGjbV)v)wSB!kF{zM43c^Qvqm9FDX2MhKj^>0^Skbj zX7bBHaUjiRaLNc2X#VU9LK{ersw}}Wo71!f2y_|#PBz+OB%^Q^X|R_+epnO4(^*>X z1LzK^H?>USwVz-wyfJnNgoCdD7nI#9X+>a%q-6?zHs;9p?^KG>LW6)&7<{fGfJ2rg z_|IR_i|12rt~SBQp2!v0drX_yCQ4BK$7LS$K{tX?az2PtNGy0MfOabA7uGQ{+#`DN zh%9g5eBmGucX5yl0Si&l{szrepno?B{?!W2#s^&!UP#%6A*&!6XC$mEH;UB%*UEK8 zHT`VsUlK?{uOdPyL8?eIpfqU)By|2tZ=nc?AV`xcK~O^*C*J@YW@+g}^d#tjn7TT`1T&35q$di^gVJ9 zQS49McMjT8;w|o#>KaMOeuA4l1zMuXV4irQk!nXjO|^c=zMT8k1PJ#7%^k_xYgEBIUgTP(Xz5>c)ZOjAZp%EE% zA=c+1&G@$H@W*$B#Ml({&ar10$7x~#Q$gJF1DXLY37le!SIDh<0gX zceyO1nO;#9&(^IRnx|I#YRe&68kj;;8LPl z60SW`tT6ziTRR#F-3!_e4~f*_|1IS~S)@&*1W;27TKo(j>$N2#AQm~<9yNFFUVs;A zS%-s4Tik&w9+Q%qTQHZw&AQ@9c^nd#Tnm(^9B{^#0_HZ(`{Y`soK~L-E)dGxbZdmK zyniZXaHWtmh`2fcqYp_un|f+bE+*Dx5I{WudN?A|wy#VQk>?~7XL0pvMKSE>HZSgt z4XJ2Io{z^T3{^7UYp-|Zh2&oqRc3*D;}$8&7+8e)fet&KkSt(N>cT9>^?myfXBOn! zqzr6NsME>zu`h6EJRXyoF#`1U7|zeabOZ!&XSAm2CAs&Q?FxDgtbgCIlEuda3YPGr zeWtE$Fj~cMtr3_vLMGqU;30G^yv8vKvhOp)!W~rw?f+h=jq#Z~fp?;ved@*woD4yx z%KXn1JS|pemu-{jY7s!wO*6-)1y4wi15|?Jb|1_0Ks01>CY?0&X zYdjACF@~MLuVOw$y*Iq3sLuNLSyHb1vac)pyueG7l?&I|;22vVY(qv!HJ}AK%2EET z&WjtGRVpDFK!r|Bg!PaINa_cGUy%_{{NWZcwJ5PRE#i-$h0j>h5lpovmeq9 z9wT?1^19xBvMb#^ap27^Er{E%4cXjk=;`mbqan~=#M`_Q{Um=x;_q3 z?9E_WBJ~UTtaYP&-(!YX!HQl>}p`#kD z`Wm-i1ME~B8S4{X?2Kva%MlyIIFl_&MU7IGUrcM%QPdVa0AeP)wWAK-y#b`nnDA$x z;>48`gQlrKHxq7IXG^X7FKI@NQie?kMX}(^62V^Kb*5^>cRjg`((dgU=K47z;cc^; zIH~`qO(W4Ktt3D79e^Yf$@+pb+y6a1%EA$qcQ!uBG~tZG<#zhEp@OBLF1RfldA+e0 zT=zLHFL(0xSoKo{eo!o#Ma@d=NAFJUtx|(#Yzmy|EzQn)wpkA$%)-mI%W^q+{^?kU z#GnVFxYLl#5pwi;W0A=F_K#x?yNM0HDN z9g*;|c}hW?)Xa7qa5HKUUw;=HPTi zKz?u!>6X!IDmyRxvy5$P?+8bN^JeR6iZH=(tz}NF`xT&sn-#grOpj|ap~q_kMudK9 zc1Qqa8|FSx-Q`rm?b}DPoD}q6mn)g#MVdYJ5&kGra@`2`fNDiTFTFob5vR5Ye#nD< zFcj9t@M1Cj1uku++~n3aUlb*1gzl=&`r%Z-)@;KQ21^9=r%3rxZHTL>GJ=|>FZxhVtx_uFYyOn;k<6VAG(T1(aqa12byRTEL z{q-!3)>F2DpzhHMW2UZx=GD*Nro3q?XHoLe;T&Q!AeD4C_sf{Bg9cL*@m=L{Izq4w zN>pcOFWaSR#{Fa^8y1rUw>evxc^P-bY+5EIeqKg84K|Lodpoxq?NDBba03)<61ANt|#L} z#g$6IbQ}0LM=P55#Q(DGTdL36uO*B3XceX+u`PcHeLG8?3}`tA+l^}ecxEBCDah6W zTxW1j5YJy&6D)@0q8YC4SK0-Ce+ak;8V z(V-xEZq7a_r0{?RAOA8l{~POq+W`9F>%&|LU5|1S?8k^`5Rf6GgubYc?@!%i@-nW; zvsHInikGL^Shlw%cr@1GC#0VJV1CM~y5SY8#;MixBYSD6yV zG>ec&abw=RR3vd)2-?%M=? zhV*7M@^bdW1a!us$vu`I{b@8TC;OB~NIk1T_i`iE{q@adp2Q2L6MX~X{Zv9v-ej@E z7+(>xn~rx>bEW)|RhZ!Pq*$O+j8oTEyCA;$@nc=WUV(g=0{5bH@`r&H3k#+c)xb?0 zdUEuucHD+n_bErHez8uet*9I4}ZWUcVdCtdjC5rcS2Ki4~qIDhpIt zY*{JhU|LaC$RT9uy}moLj4jbnf%4*@o0@E(5q&zd!iQrCg@L6%K21%mxH9KS2C3I0^Y)lAd#q!8TgBf~#)$Sh!bga0U|*I@<%Q-4zr z#Ris&q5#`j#SI5ep&la18*`fvlrO$)0gd^H({k9O;qUSEtwXXzDqK7&0L|i$wPlZC zpO`cvkSJ`(ar>9#{iIjdZb43B18T`w_?;7->cn{HGYKtumXe(d9gr3oHS-GdgErDvw*jYTD#Gl^)&>r{X0q zofqH|b?qCS^4**|zOh$oK~NPR^P^R5$R7EAg8%peA2~SzihA*JYKGY2<^SIl)g)>E zt(mqL;6(C&)@9Svvs~NJn}#;?zn33#fm&}DBQPS&6v!0Cdwff{M)#isqjw@onPrb0 z{OUeyDg5UocK z%>ZHk?2}vbK;*_#qm)BMzUXcT(!t6Zy_w0!<4N@EH`z=rfu9K9Uag_WxxM_RFo;*! z&EZb-hhOR({gMhBu*c5qbYmOlmc~$kOP5_NXV^zv_|xe0{mt%+E1o)4N2PC186a@N zy4H|HbWjS>TAH6vsIRUD@+!+OyPeqx&NW)zvbY6!RpIlZ%F>)FE1MYydwM0iV0HQ$mtwm RAynMoF-BPn{ap$B@?Z0!{uclM literal 0 HcmV?d00001 diff --git a/en/chapter_tree/avl_tree.assets/avltree_left_rotate.png b/en/chapter_tree/avl_tree.assets/avltree_left_rotate.png new file mode 100644 index 0000000000000000000000000000000000000000..3ef850f4a61bb5292aebc9de22d1740c624afa9c GIT binary patch literal 21444 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/avl_tree.assets/avltree_left_rotate_with_grandchild.png b/en/chapter_tree/avl_tree.assets/avltree_left_rotate_with_grandchild.png new file mode 100644 index 0000000000000000000000000000000000000000..8cdb2244898eec1c881c07e6ae5408d2f4bda6b1 GIT binary patch literal 25314 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 Q%KwygG;U%m)Nm310XH>W4gdfE literal 0 HcmV?d00001 diff --git a/en/chapter_tree/avl_tree.assets/avltree_right_rotate_step1.png b/en/chapter_tree/avl_tree.assets/avltree_right_rotate_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..c0947cb5a61316c0596a122521d64f76d2d824dc GIT binary patch literal 10017 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 k|2W9S3mc=@|CYH7X(g~7Ov`yn{v$k=#UFY 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/avl_tree.assets/avltree_right_rotate_step3.png b/en/chapter_tree/avl_tree.assets/avltree_right_rotate_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..bb366c15d9c376cfacccc2439c37d9ff22e56222 GIT binary patch literal 17700 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 V*|~?Kk(2+5RG(-m)hbxM{VxKv!cPDI literal 0 HcmV?d00001 diff --git a/en/chapter_tree/avl_tree.assets/avltree_right_rotate_with_grandchild.png b/en/chapter_tree/avl_tree.assets/avltree_right_rotate_with_grandchild.png new file mode 100644 index 0000000000000000000000000000000000000000..086be7880ac01e3bdcde250aa156b434f5575c37 GIT binary patch literal 25747 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 YfsX^K5@}h(fB&^L)$~*=lwqO&2V6KgYybcN literal 0 HcmV?d00001 diff --git a/en/chapter_tree/avl_tree.assets/avltree_rotation_cases.png b/en/chapter_tree/avl_tree.assets/avltree_rotation_cases.png new file mode 100644 index 0000000000000000000000000000000000000000..643d0ee9ca0927aeb54a7d453b5e9b939d920a8e GIT binary patch literal 22171 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + 7.5 AVL Tree * - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    7.5   AVL tree *

    +

    In the "Binary Search Tree" section, we mentioned that after multiple insertions and removals, a binary search tree might degrade to a linked list. In such cases, the time complexity of all operations degrades from \(O(\log n)\) to \(O(n)\).

    +

    As shown in the Figure 7-24 , after two node removal operations, this binary search tree will degrade into a linked list.

    +

    Degradation of an AVL tree after removing nodes

    +

    Figure 7-24   Degradation of an AVL tree after removing nodes

    + +

    For example, in the perfect binary tree shown in the Figure 7-25 , after inserting two nodes, the tree will lean heavily to the left, and the time complexity of search operations will also degrade.

    +

    Degradation of an AVL tree after inserting nodes

    +

    Figure 7-25   Degradation of an AVL tree after inserting nodes

    + +

    In 1962, G. M. Adelson-Velsky and E. M. Landis proposed the "AVL Tree" in their paper "An algorithm for the organization of information". The paper detailed a series of operations to ensure that after continuously adding and removing nodes, the AVL tree would not degrade, thus maintaining the time complexity of various operations at \(O(\log n)\) level. In other words, in scenarios where frequent additions, removals, searches, and modifications are needed, the AVL tree can always maintain efficient data operation performance, which has great application value.

    +

    7.5.1   Common terminology in AVL trees

    +

    An AVL tree is both a binary search tree and a balanced binary tree, satisfying all properties of these two types of binary trees, hence it is a "balanced binary search tree".

    +

    1.   Node height

    +

    Since the operations related to AVL trees require obtaining node heights, we need to add a height variable to the node class:

    +
    +
    +
    +
    class TreeNode:
+    """AVL tree node"""
+    def __init__(self, val: int):
+        self.val: int = val                 # Node value
+        self.height: int = 0                # Node height
+        self.left: TreeNode | None = None   # Left child reference
+        self.right: TreeNode | None = None  # Right child reference
+
    +
    +
    +
    /* AVL tree node */
+struct TreeNode {
+    int val{};          // Node value
+    int height = 0;     // Node height
+    TreeNode *left{};   // Left child
+    TreeNode *right{};  // Right child
+    TreeNode() = default;
+    explicit TreeNode(int x) : val(x){}
+};
+
    +
    +
    +
    /* AVL tree node */
+class TreeNode {
+    public int val;        // Node value
+    public int height;     // Node height
+    public TreeNode left;  // Left child
+    public TreeNode right; // Right child
+    public TreeNode(int x) { val = x; }
+}
+
    +
    +
    +
    /* AVL tree node */
+class TreeNode(int? x) {
+    public int? val = x;    // Node value
+    public int height;      // Node height
+    public TreeNode? left;  // Left child reference
+    public TreeNode? right; // Right child reference
+}
+
    +
    +
    +
    /* AVL tree node */
+type TreeNode struct {
+    Val    int       // Node value
+    Height int       // Node height
+    Left   *TreeNode // Left child reference
+    Right  *TreeNode // Right child reference
+}
+
    +
    +
    +
    /* AVL tree node */
+class TreeNode {
+    var val: Int // Node value
+    var height: Int // Node height
+    var left: TreeNode? // Left child
+    var right: TreeNode? // Right child
+
+    init(x: Int) {
+        val = x
+        height = 0
+    }
+}
+
    +
    +
    +
    /* AVL tree node */
+class TreeNode {
+    val; // Node value
+    height; // Node height
+    left; // Left child pointer
+    right; // Right child pointer
+    constructor(val, left, right, height) {
+        this.val = val === undefined ? 0 : val;
+        this.height = height === undefined ? 0 : height;
+        this.left = left === undefined ? null : left;
+        this.right = right === undefined ? null : right;
+    }
+}
+
    +
    +
    +
    /* AVL tree node */
+class TreeNode {
+    val: number;            // Node value
+    height: number;         // Node height
+    left: TreeNode | null;  // Left child pointer
+    right: TreeNode | null; // Right child pointer
+    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.height = height === undefined ? 0 : height; 
+        this.left = left === undefined ? null : left; 
+        this.right = right === undefined ? null : right; 
+    }
+}
+
    +
    +
    +
    /* AVL tree node */
+class TreeNode {
+  int val;         // Node value
+  int height;      // Node height
+  TreeNode? left;  // Left child
+  TreeNode? right; // Right child
+  TreeNode(this.val, [this.height = 0, this.left, this.right]);
+}
+
    +
    +
    +
    use std::rc::Rc;
+use std::cell::RefCell;
+
+/* AVL tree node */
+struct TreeNode {
+    val: i32,                               // Node value
+    height: i32,                            // Node height
+    left: Option<Rc<RefCell<TreeNode>>>,    // Left child
+    right: Option<Rc<RefCell<TreeNode>>>,   // Right child
+}
+
+impl TreeNode {
+    /* Constructor */
+    fn new(val: i32) -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(Self {
+            val,
+            height: 0,
+            left: None,
+            right: None
+        }))
+    }
+}
+
    +
    +
    +
    /* AVL tree node */
+TreeNode struct TreeNode {
+    int val;
+    int height;
+    struct TreeNode *left;
+    struct TreeNode *right;
+} TreeNode;
+
+/* Constructor */
+TreeNode *newTreeNode(int val) {
+    TreeNode *node;
+
+    node = (TreeNode *)malloc(sizeof(TreeNode));
+    node->val = val;
+    node->height = 0;
+    node->left = NULL;
+    node->right = NULL;
+    return node;
+}
+
    +
    +
    +
    /* AVL tree node */
+class TreeNode(val _val: Int) {  // Node value
+    val height: Int = 0          // Node height
+    val left: TreeNode? = null   // Left child
+    val right: TreeNode? = null  // Right child
+}
+
    +
    +
    +
    
+
    +
    +
    +
    
+
    +
    +
    +
    +

    The "node height" refers to the distance from that node to its farthest leaf node, i.e., the number of "edges" passed. It is important to note that the height of a leaf node is \(0\), and the height of a null node is \(-1\). We will create two utility functions for getting and updating the height of a node:

    +
    +
    +
    +
    avl_tree.py
    def height(self, node: TreeNode | None) -> int:
+    """获取节点高度"""
+    # 空节点高度为 -1 ，叶节点高度为 0
+    if node is not None:
+        return node.height
+    return -1
+
+def update_height(self, node: TreeNode | None):
+    """更新节点高度"""
+    # 节点高度等于最高子树高度 + 1
+    node.height = max([self.height(node.left), self.height(node.right)]) + 1
+
    +
    +
    +
    avl_tree.cpp
    /* 获取节点高度 */
+int height(TreeNode *node) {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    return node == nullptr ? -1 : node->height;
+}
+
+/* 更新节点高度 */
+void updateHeight(TreeNode *node) {
+    // 节点高度等于最高子树高度 + 1
+    node->height = max(height(node->left), height(node->right)) + 1;
+}
+
    +
    +
    +
    avl_tree.java
    /* 获取节点高度 */
+int height(TreeNode node) {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    return node == null ? -1 : node.height;
+}
+
+/* 更新节点高度 */
+void updateHeight(TreeNode node) {
+    // 节点高度等于最高子树高度 + 1
+    node.height = Math.max(height(node.left), height(node.right)) + 1;
+}
+
    +
    +
    +
    avl_tree.cs
    /* 获取节点高度 */
+int Height(TreeNode? node) {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    return node == null ? -1 : node.height;
+}
+
+/* 更新节点高度 */
+void UpdateHeight(TreeNode node) {
+    // 节点高度等于最高子树高度 + 1
+    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;
+}
+
    +
    +
    +
    avl_tree.go
    /* 获取节点高度 */
+func (t *aVLTree) height(node *TreeNode) int {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    if node != nil {
+        return node.Height
+    }
+    return -1
+}
+
+/* 更新节点高度 */
+func (t *aVLTree) updateHeight(node *TreeNode) {
+    lh := t.height(node.Left)
+    rh := t.height(node.Right)
+    // 节点高度等于最高子树高度 + 1
+    if lh > rh {
+        node.Height = lh + 1
+    } else {
+        node.Height = rh + 1
+    }
+}
+
    +
    +
    +
    avl_tree.swift
    /* 获取节点高度 */
+func height(node: TreeNode?) -> Int {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    node?.height ?? -1
+}
+
+/* 更新节点高度 */
+func updateHeight(node: TreeNode?) {
+    // 节点高度等于最高子树高度 + 1
+    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1
+}
+
    +
    +
    +
    avl_tree.js
    /* 获取节点高度 */
+height(node) {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    return node === null ? -1 : node.height;
+}
+
+/* 更新节点高度 */
+#updateHeight(node) {
+    // 节点高度等于最高子树高度 + 1
+    node.height =
+        Math.max(this.height(node.left), this.height(node.right)) + 1;
+}
+
    +
    +
    +
    avl_tree.ts
    /* 获取节点高度 */
+height(node: TreeNode): number {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    return node === null ? -1 : node.height;
+}
+
+/* 更新节点高度 */
+updateHeight(node: TreeNode): void {
+    // 节点高度等于最高子树高度 + 1
+    node.height =
+        Math.max(this.height(node.left), this.height(node.right)) + 1;
+}
+
    +
    +
    +
    avl_tree.dart
    /* 获取节点高度 */
+int height(TreeNode? node) {
+  // 空节点高度为 -1 ，叶节点高度为 0
+  return node == null ? -1 : node.height;
+}
+
+/* 更新节点高度 */
+void updateHeight(TreeNode? node) {
+  // 节点高度等于最高子树高度 + 1
+  node!.height = max(height(node.left), height(node.right)) + 1;
+}
+
    +
    +
    +
    avl_tree.rs
    /* 获取节点高度 */
+fn height(node: OptionTreeNodeRc) -> i32 {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    match node {
+        Some(node) => node.borrow().height,
+        None => -1,
+    }
+}
+
+/* 更新节点高度 */
+fn update_height(node: OptionTreeNodeRc) {
+    if let Some(node) = node {
+        let left = node.borrow().left.clone();
+        let right = node.borrow().right.clone();
+        // 节点高度等于最高子树高度 + 1
+        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;
+    }
+}
+
    +
    +
    +
    avl_tree.c
    /* 获取节点高度 */
+int height(TreeNode *node) {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    if (node != NULL) {
+        return node->height;
+    }
+    return -1;
+}
+
+/* 更新节点高度 */
+void updateHeight(TreeNode *node) {
+    int lh = height(node->left);
+    int rh = height(node->right);
+    // 节点高度等于最高子树高度 + 1
+    if (lh > rh) {
+        node->height = lh + 1;
+    } else {
+        node->height = rh + 1;
+    }
+}
+
    +
    +
    +
    avl_tree.kt
    /* 获取节点高度 */
+fun height(node: TreeNode?): Int {
+    // 空节点高度为 -1 ，叶节点高度为 0
+    return node?.height ?: -1
+}
+
+/* 更新节点高度 */
+fun updateHeight(node: TreeNode?) {
+    // 节点高度等于最高子树高度 + 1
+    node?.height = (max(height(node?.left).toDouble(), height(node?.right).toDouble()) + 1).toInt()
+}
+
    +
    +
    +
    avl_tree.rb
    [class]{AVLTree}-[func]{height}
+
+[class]{AVLTree}-[func]{update_height}
+
    +
    +
    +
    avl_tree.zig
    // 获取节点高度
+fn height(self: *Self, node: ?*inc.TreeNode(T)) i32 {
+    _ = self;
+    // 空节点高度为 -1 ，叶节点高度为 0
+    return if (node == null) -1 else node.?.height;
+}
+
+// 更新节点高度
+fn updateHeight(self: *Self, node: ?*inc.TreeNode(T)) void {
+    // 节点高度等于最高子树高度 + 1
+    node.?.height = @max(self.height(node.?.left), self.height(node.?.right)) + 1;
+}
+
    +
    +
    +
    +

    2.   Node balance factor

    +

    The "balance factor" of a node is defined as the height of the node's left subtree minus the height of its right subtree, with the balance factor of a null node defined as \(0\). We will also encapsulate the functionality of obtaining the node balance factor into a function for easy use later on:

    +
    +
    +
    +
    avl_tree.py
    def balance_factor(self, node: TreeNode | None) -> int:
+    """获取平衡因子"""
+    # 空节点平衡因子为 0
+    if node is None:
+        return 0
+    # 节点平衡因子 = 左子树高度 - 右子树高度
+    return self.height(node.left) - self.height(node.right)
+
    +
    +
    +
    avl_tree.cpp
    /* 获取平衡因子 */
+int balanceFactor(TreeNode *node) {
+    // 空节点平衡因子为 0
+    if (node == nullptr)
+        return 0;
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return height(node->left) - height(node->right);
+}
+
    +
    +
    +
    avl_tree.java
    /* 获取平衡因子 */
+int balanceFactor(TreeNode node) {
+    // 空节点平衡因子为 0
+    if (node == null)
+        return 0;
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return height(node.left) - height(node.right);
+}
+
    +
    +
    +
    avl_tree.cs
    /* 获取平衡因子 */
+int BalanceFactor(TreeNode? node) {
+    // 空节点平衡因子为 0
+    if (node == null) return 0;
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return Height(node.left) - Height(node.right);
+}
+
    +
    +
    +
    avl_tree.go
    /* 获取平衡因子 */
+func (t *aVLTree) balanceFactor(node *TreeNode) int {
+    // 空节点平衡因子为 0
+    if node == nil {
+        return 0
+    }
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return t.height(node.Left) - t.height(node.Right)
+}
+
    +
    +
    +
    avl_tree.swift
    /* 获取平衡因子 */
+func balanceFactor(node: TreeNode?) -> Int {
+    // 空节点平衡因子为 0
+    guard let node = node else { return 0 }
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return height(node: node.left) - height(node: node.right)
+}
+
    +
    +
    +
    avl_tree.js
    /* 获取平衡因子 */
+balanceFactor(node) {
+    // 空节点平衡因子为 0
+    if (node === null) return 0;
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return this.height(node.left) - this.height(node.right);
+}
+
    +
    +
    +
    avl_tree.ts
    /* 获取平衡因子 */
+balanceFactor(node: TreeNode): number {
+    // 空节点平衡因子为 0
+    if (node === null) return 0;
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return this.height(node.left) - this.height(node.right);
+}
+
    +
    +
    +
    avl_tree.dart
    /* 获取平衡因子 */
+int balanceFactor(TreeNode? node) {
+  // 空节点平衡因子为 0
+  if (node == null) return 0;
+  // 节点平衡因子 = 左子树高度 - 右子树高度
+  return height(node.left) - height(node.right);
+}
+
    +
    +
    +
    avl_tree.rs
    /* 获取平衡因子 */
+fn balance_factor(node: OptionTreeNodeRc) -> i32 {
+    match node {
+        // 空节点平衡因子为 0
+        None => 0,
+        // 节点平衡因子 = 左子树高度 - 右子树高度
+        Some(node) => {
+            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())
+        }
+    }
+}
+
    +
    +
    +
    avl_tree.c
    /* 获取平衡因子 */
+int balanceFactor(TreeNode *node) {
+    // 空节点平衡因子为 0
+    if (node == NULL) {
+        return 0;
+    }
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return height(node->left) - height(node->right);
+}
+
    +
    +
    +
    avl_tree.kt
    /* 获取平衡因子 */
+fun balanceFactor(node: TreeNode?): Int {
+    // 空节点平衡因子为 0
+    if (node == null) return 0
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return height(node.left) - height(node.right)
+}
+
    +
    +
    +
    avl_tree.rb
    [class]{AVLTree}-[func]{balance_factor}
+
    +
    +
    +
    avl_tree.zig
    // 获取平衡因子
+fn balanceFactor(self: *Self, node: ?*inc.TreeNode(T)) i32 {
+    // 空节点平衡因子为 0
+    if (node == null) return 0;
+    // 节点平衡因子 = 左子树高度 - 右子树高度
+    return self.height(node.?.left) - self.height(node.?.right);
+}
+
    +
    +
    +
    +
    +

    Note

    +

    Let the balance factor be \(f\), then the balance factor of any node in an AVL tree satisfies \(-1 \le f \le 1\).

    +
    +

    7.5.2   Rotations in AVL trees

    +

    The characteristic feature of an AVL tree is the "rotation" operation, which can restore balance to an unbalanced node without affecting the in-order traversal sequence of the binary tree. In other words, the rotation operation can maintain the property of a "binary search tree" while also turning the tree back into a "balanced binary tree".

    +

    We call nodes with an absolute balance factor \(> 1\) "unbalanced nodes". Depending on the type of imbalance, there are four kinds of rotations: right rotation, left rotation, right-left rotation, and left-right rotation. Below, we detail these rotation operations.

    +

    1.   Right rotation

    +

    As shown in the Figure 7-26 , the first unbalanced node from the bottom up in the binary tree is "node 3". Focusing on the subtree with this unbalanced node as the root, denoted as node, and its left child as child, perform a "right rotation". After the right rotation, the subtree is balanced again while still maintaining the properties of a binary search tree.

    +
    +
    +
    +

    Steps of right rotation

    +
    +
    +

    avltree_right_rotate_step2

    +
    +
    +

    avltree_right_rotate_step3

    +
    +
    +

    avltree_right_rotate_step4

    +
    +
    +
    +

    Figure 7-26   Steps of right rotation

    + +

    As shown in the Figure 7-27 , when the child node has a right child (denoted as grand_child), a step needs to be added in the right rotation: set grand_child as the left child of node.

    +

    Right rotation with grand_child

    +

    Figure 7-27   Right rotation with grand_child

    + +

    "Right rotation" is a figurative term; in practice, it is achieved by modifying node pointers, as shown in the following code:

    +
    +
    +
    +
    avl_tree.py
    def right_rotate(self, node: TreeNode | None) -> TreeNode | None:
+    """右旋操作"""
+    child = node.left
+    grand_child = child.right
+    # 以 child 为原点，将 node 向右旋转
+    child.right = node
+    node.left = grand_child
+    # 更新节点高度
+    self.update_height(node)
+    self.update_height(child)
+    # 返回旋转后子树的根节点
+    return child
+
    +
    +
    +
    avl_tree.cpp
    /* 右旋操作 */
+TreeNode *rightRotate(TreeNode *node) {
+    TreeNode *child = node->left;
+    TreeNode *grandChild = child->right;
+    // 以 child 为原点，将 node 向右旋转
+    child->right = node;
+    node->left = grandChild;
+    // 更新节点高度
+    updateHeight(node);
+    updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.java
    /* 右旋操作 */
+TreeNode rightRotate(TreeNode node) {
+    TreeNode child = node.left;
+    TreeNode grandChild = child.right;
+    // 以 child 为原点，将 node 向右旋转
+    child.right = node;
+    node.left = grandChild;
+    // 更新节点高度
+    updateHeight(node);
+    updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.cs
    /* 右旋操作 */
+TreeNode? RightRotate(TreeNode? node) {
+    TreeNode? child = node?.left;
+    TreeNode? grandChild = child?.right;
+    // 以 child 为原点，将 node 向右旋转
+    child.right = node;
+    node.left = grandChild;
+    // 更新节点高度
+    UpdateHeight(node);
+    UpdateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.go
    /* 右旋操作 */
+func (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {
+    child := node.Left
+    grandChild := child.Right
+    // 以 child 为原点，将 node 向右旋转
+    child.Right = node
+    node.Left = grandChild
+    // 更新节点高度
+    t.updateHeight(node)
+    t.updateHeight(child)
+    // 返回旋转后子树的根节点
+    return child
+}
+
    +
    +
    +
    avl_tree.swift
    /* 右旋操作 */
+func rightRotate(node: TreeNode?) -> TreeNode? {
+    let child = node?.left
+    let grandChild = child?.right
+    // 以 child 为原点，将 node 向右旋转
+    child?.right = node
+    node?.left = grandChild
+    // 更新节点高度
+    updateHeight(node: node)
+    updateHeight(node: child)
+    // 返回旋转后子树的根节点
+    return child
+}
+
    +
    +
    +
    avl_tree.js
    /* 右旋操作 */
+#rightRotate(node) {
+    const child = node.left;
+    const grandChild = child.right;
+    // 以 child 为原点，将 node 向右旋转
+    child.right = node;
+    node.left = grandChild;
+    // 更新节点高度
+    this.#updateHeight(node);
+    this.#updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.ts
    /* 右旋操作 */
+rightRotate(node: TreeNode): TreeNode {
+    const child = node.left;
+    const grandChild = child.right;
+    // 以 child 为原点，将 node 向右旋转
+    child.right = node;
+    node.left = grandChild;
+    // 更新节点高度
+    this.updateHeight(node);
+    this.updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.dart
    /* 右旋操作 */
+TreeNode? rightRotate(TreeNode? node) {
+  TreeNode? child = node!.left;
+  TreeNode? grandChild = child!.right;
+  // 以 child 为原点，将 node 向右旋转
+  child.right = node;
+  node.left = grandChild;
+  // 更新节点高度
+  updateHeight(node);
+  updateHeight(child);
+  // 返回旋转后子树的根节点
+  return child;
+}
+
    +
    +
    +
    avl_tree.rs
    /* 右旋操作 */
+fn right_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+    match node {
+        Some(node) => {
+            let child = node.borrow().left.clone().unwrap();
+            let grand_child = child.borrow().right.clone();
+            // 以 child 为原点，将 node 向右旋转
+            child.borrow_mut().right = Some(node.clone());
+            node.borrow_mut().left = grand_child;
+            // 更新节点高度
+            Self::update_height(Some(node));
+            Self::update_height(Some(child.clone()));
+            // 返回旋转后子树的根节点
+            Some(child)
+        }
+        None => None,
+    }
+}
+
    +
    +
    +
    avl_tree.c
    /* 右旋操作 */
+TreeNode *rightRotate(TreeNode *node) {
+    TreeNode *child, *grandChild;
+    child = node->left;
+    grandChild = child->right;
+    // 以 child 为原点，将 node 向右旋转
+    child->right = node;
+    node->left = grandChild;
+    // 更新节点高度
+    updateHeight(node);
+    updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.kt
    /* 右旋操作 */
+fun rightRotate(node: TreeNode?): TreeNode {
+    val child = node!!.left
+    val grandChild = child!!.right
+    // 以 child 为原点，将 node 向右旋转
+    child.right = node
+    node.left = grandChild
+    // 更新节点高度
+    updateHeight(node)
+    updateHeight(child)
+    // 返回旋转后子树的根节点
+    return child
+}
+
    +
    +
    +
    avl_tree.rb
    [class]{AVLTree}-[func]{right_rotate}
+
    +
    +
    +
    avl_tree.zig
    // 右旋操作
+fn rightRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
+    var child = node.?.left;
+    var grandChild = child.?.right;
+    // 以 child 为原点，将 node 向右旋转
+    child.?.right = node;
+    node.?.left = grandChild;
+    // 更新节点高度
+    self.updateHeight(node);
+    self.updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    +

    2.   Left rotation

    +

    Correspondingly, if considering the "mirror" of the above unbalanced binary tree, the "left rotation" operation shown in the Figure 7-28 needs to be performed.

    +

    Left rotation operation

    +

    Figure 7-28   Left rotation operation

    + +

    Similarly, as shown in the Figure 7-29 , when the child node has a left child (denoted as grand_child), a step needs to be added in the left rotation: set grand_child as the right child of node.

    +

    Left rotation with grand_child

    +

    Figure 7-29   Left rotation with grand_child

    + +

    It can be observed that the right and left rotation operations are logically symmetrical, and they solve two symmetrical types of imbalance. Based on symmetry, by replacing all left with right, and all right with left in the implementation code of right rotation, we can get the implementation code for left rotation:

    +
    +
    +
    +
    avl_tree.py
    def left_rotate(self, node: TreeNode | None) -> TreeNode | None:
+    """左旋操作"""
+    child = node.right
+    grand_child = child.left
+    # 以 child 为原点，将 node 向左旋转
+    child.left = node
+    node.right = grand_child
+    # 更新节点高度
+    self.update_height(node)
+    self.update_height(child)
+    # 返回旋转后子树的根节点
+    return child
+
    +
    +
    +
    avl_tree.cpp
    /* 左旋操作 */
+TreeNode *leftRotate(TreeNode *node) {
+    TreeNode *child = node->right;
+    TreeNode *grandChild = child->left;
+    // 以 child 为原点，将 node 向左旋转
+    child->left = node;
+    node->right = grandChild;
+    // 更新节点高度
+    updateHeight(node);
+    updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.java
    /* 左旋操作 */
+TreeNode leftRotate(TreeNode node) {
+    TreeNode child = node.right;
+    TreeNode grandChild = child.left;
+    // 以 child 为原点，将 node 向左旋转
+    child.left = node;
+    node.right = grandChild;
+    // 更新节点高度
+    updateHeight(node);
+    updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.cs
    /* 左旋操作 */
+TreeNode? LeftRotate(TreeNode? node) {
+    TreeNode? child = node?.right;
+    TreeNode? grandChild = child?.left;
+    // 以 child 为原点，将 node 向左旋转
+    child.left = node;
+    node.right = grandChild;
+    // 更新节点高度
+    UpdateHeight(node);
+    UpdateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.go
    /* 左旋操作 */
+func (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {
+    child := node.Right
+    grandChild := child.Left
+    // 以 child 为原点，将 node 向左旋转
+    child.Left = node
+    node.Right = grandChild
+    // 更新节点高度
+    t.updateHeight(node)
+    t.updateHeight(child)
+    // 返回旋转后子树的根节点
+    return child
+}
+
    +
    +
    +
    avl_tree.swift
    /* 左旋操作 */
+func leftRotate(node: TreeNode?) -> TreeNode? {
+    let child = node?.right
+    let grandChild = child?.left
+    // 以 child 为原点，将 node 向左旋转
+    child?.left = node
+    node?.right = grandChild
+    // 更新节点高度
+    updateHeight(node: node)
+    updateHeight(node: child)
+    // 返回旋转后子树的根节点
+    return child
+}
+
    +
    +
    +
    avl_tree.js
    /* 左旋操作 */
+#leftRotate(node) {
+    const child = node.right;
+    const grandChild = child.left;
+    // 以 child 为原点，将 node 向左旋转
+    child.left = node;
+    node.right = grandChild;
+    // 更新节点高度
+    this.#updateHeight(node);
+    this.#updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.ts
    /* 左旋操作 */
+leftRotate(node: TreeNode): TreeNode {
+    const child = node.right;
+    const grandChild = child.left;
+    // 以 child 为原点，将 node 向左旋转
+    child.left = node;
+    node.right = grandChild;
+    // 更新节点高度
+    this.updateHeight(node);
+    this.updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.dart
    /* 左旋操作 */
+TreeNode? leftRotate(TreeNode? node) {
+  TreeNode? child = node!.right;
+  TreeNode? grandChild = child!.left;
+  // 以 child 为原点，将 node 向左旋转
+  child.left = node;
+  node.right = grandChild;
+  // 更新节点高度
+  updateHeight(node);
+  updateHeight(child);
+  // 返回旋转后子树的根节点
+  return child;
+}
+
    +
    +
    +
    avl_tree.rs
    /* 左旋操作 */
+fn left_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+    match node {
+        Some(node) => {
+            let child = node.borrow().right.clone().unwrap();
+            let grand_child = child.borrow().left.clone();
+            // 以 child 为原点，将 node 向左旋转
+            child.borrow_mut().left = Some(node.clone());
+            node.borrow_mut().right = grand_child;
+            // 更新节点高度
+            Self::update_height(Some(node));
+            Self::update_height(Some(child.clone()));
+            // 返回旋转后子树的根节点
+            Some(child)
+        }
+        None => None,
+    }
+}
+
    +
    +
    +
    avl_tree.c
    /* 左旋操作 */
+TreeNode *leftRotate(TreeNode *node) {
+    TreeNode *child, *grandChild;
+    child = node->right;
+    grandChild = child->left;
+    // 以 child 为原点，将 node 向左旋转
+    child->left = node;
+    node->right = grandChild;
+    // 更新节点高度
+    updateHeight(node);
+    updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    avl_tree.kt
    /* 左旋操作 */
+fun leftRotate(node: TreeNode?): TreeNode {
+    val child = node!!.right
+    val grandChild = child!!.left
+    // 以 child 为原点，将 node 向左旋转
+    child.left = node
+    node.right = grandChild
+    // 更新节点高度
+    updateHeight(node)
+    updateHeight(child)
+    // 返回旋转后子树的根节点
+    return child
+}
+
    +
    +
    +
    avl_tree.rb
    [class]{AVLTree}-[func]{left_rotate}
+
    +
    +
    +
    avl_tree.zig
    // 左旋操作
+fn leftRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
+    var child = node.?.right;
+    var grandChild = child.?.left;
+    // 以 child 为原点，将 node 向左旋转
+    child.?.left = node;
+    node.?.right = grandChild;
+    // 更新节点高度
+    self.updateHeight(node);
+    self.updateHeight(child);
+    // 返回旋转后子树的根节点
+    return child;
+}
+
    +
    +
    +
    +

    3.   Right-left rotation

    +

    For the unbalanced node 3 shown in the Figure 7-30 , using either left or right rotation alone cannot restore balance to the subtree. In this case, a "left rotation" needs to be performed on child first, followed by a "right rotation" on node.

    +

    Right-left rotation

    +

    Figure 7-30   Right-left rotation

    + +

    4.   Left-right rotation

    +

    As shown in the Figure 7-31 , for the mirror case of the above unbalanced binary tree, a "right rotation" needs to be performed on child first, followed by a "left rotation" on node.

    +

    Left-right rotation

    +

    Figure 7-31   Left-right rotation

    + +

    5.   Choice of rotation

    +

    The four kinds of imbalances shown in the Figure 7-32 correspond to the cases described above, respectively requiring right rotation, left-right rotation, right-left rotation, and left rotation.

    +

    The four rotation cases of AVL tree

    +

    Figure 7-32   The four rotation cases of AVL tree

    + +

    As shown in the Table 7-3 , we determine which of the above cases an unbalanced node belongs to by judging the sign of the balance factor of the unbalanced node and its higher-side child's balance factor.

    +

    Table 7-3   Conditions for Choosing Among the Four Rotation Cases

    + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Balance factor of unbalanced nodeBalance factor of child nodeRotation method to use
    \(> 1\) (Left-leaning tree)\(\geq 0\)Right rotation
    \(> 1\) (Left-leaning tree)\(<0\)Left rotation then right rotation
    \(< -1\) (Right-leaning tree)\(\leq 0\)Left rotation
    \(< -1\) (Right-leaning tree)\(>0\)Right rotation then left rotation
    +
    +

    For convenience, we encapsulate the rotation operations into a function. With this function, we can perform rotations on various kinds of imbalances, restoring balance to unbalanced nodes. The code is as follows:

    +
    +
    +
    +
    avl_tree.py
    def rotate(self, node: TreeNode | None) -> TreeNode | None:
+    """执行旋转操作，使该子树重新恢复平衡"""
+    # 获取节点 node 的平衡因子
+    balance_factor = self.balance_factor(node)
+    # 左偏树
+    if balance_factor > 1:
+        if self.balance_factor(node.left) >= 0:
+            # 右旋
+            return self.right_rotate(node)
+        else:
+            # 先左旋后右旋
+            node.left = self.left_rotate(node.left)
+            return self.right_rotate(node)
+    # 右偏树
+    elif balance_factor < -1:
+        if self.balance_factor(node.right) <= 0:
+            # 左旋
+            return self.left_rotate(node)
+        else:
+            # 先右旋后左旋
+            node.right = self.right_rotate(node.right)
+            return self.left_rotate(node)
+    # 平衡树，无须旋转，直接返回
+    return node
+
    +
    +
    +
    avl_tree.cpp
    /* 执行旋转操作，使该子树重新恢复平衡 */
+TreeNode *rotate(TreeNode *node) {
+    // 获取节点 node 的平衡因子
+    int _balanceFactor = balanceFactor(node);
+    // 左偏树
+    if (_balanceFactor > 1) {
+        if (balanceFactor(node->left) >= 0) {
+            // 右旋
+            return rightRotate(node);
+        } else {
+            // 先左旋后右旋
+            node->left = leftRotate(node->left);
+            return rightRotate(node);
+        }
+    }
+    // 右偏树
+    if (_balanceFactor < -1) {
+        if (balanceFactor(node->right) <= 0) {
+            // 左旋
+            return leftRotate(node);
+        } else {
+            // 先右旋后左旋
+            node->right = rightRotate(node->right);
+            return leftRotate(node);
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node;
+}
+
    +
    +
    +
    avl_tree.java
    /* 执行旋转操作，使该子树重新恢复平衡 */
+TreeNode rotate(TreeNode node) {
+    // 获取节点 node 的平衡因子
+    int balanceFactor = balanceFactor(node);
+    // 左偏树
+    if (balanceFactor > 1) {
+        if (balanceFactor(node.left) >= 0) {
+            // 右旋
+            return rightRotate(node);
+        } else {
+            // 先左旋后右旋
+            node.left = leftRotate(node.left);
+            return rightRotate(node);
+        }
+    }
+    // 右偏树
+    if (balanceFactor < -1) {
+        if (balanceFactor(node.right) <= 0) {
+            // 左旋
+            return leftRotate(node);
+        } else {
+            // 先右旋后左旋
+            node.right = rightRotate(node.right);
+            return leftRotate(node);
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node;
+}
+
    +
    +
    +
    avl_tree.cs
    /* 执行旋转操作，使该子树重新恢复平衡 */
+TreeNode? Rotate(TreeNode? node) {
+    // 获取节点 node 的平衡因子
+    int balanceFactorInt = BalanceFactor(node);
+    // 左偏树
+    if (balanceFactorInt > 1) {
+        if (BalanceFactor(node?.left) >= 0) {
+            // 右旋
+            return RightRotate(node);
+        } else {
+            // 先左旋后右旋
+            node!.left = LeftRotate(node!.left);
+            return RightRotate(node);
+        }
+    }
+    // 右偏树
+    if (balanceFactorInt < -1) {
+        if (BalanceFactor(node?.right) <= 0) {
+            // 左旋
+            return LeftRotate(node);
+        } else {
+            // 先右旋后左旋
+            node!.right = RightRotate(node!.right);
+            return LeftRotate(node);
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node;
+}
+
    +
    +
    +
    avl_tree.go
    /* 执行旋转操作，使该子树重新恢复平衡 */
+func (t *aVLTree) rotate(node *TreeNode) *TreeNode {
+    // 获取节点 node 的平衡因子
+    // Go 推荐短变量，这里 bf 指代 t.balanceFactor
+    bf := t.balanceFactor(node)
+    // 左偏树
+    if bf > 1 {
+        if t.balanceFactor(node.Left) >= 0 {
+            // 右旋
+            return t.rightRotate(node)
+        } else {
+            // 先左旋后右旋
+            node.Left = t.leftRotate(node.Left)
+            return t.rightRotate(node)
+        }
+    }
+    // 右偏树
+    if bf < -1 {
+        if t.balanceFactor(node.Right) <= 0 {
+            // 左旋
+            return t.leftRotate(node)
+        } else {
+            // 先右旋后左旋
+            node.Right = t.rightRotate(node.Right)
+            return t.leftRotate(node)
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node
+}
+
    +
    +
    +
    avl_tree.swift
    /* 执行旋转操作，使该子树重新恢复平衡 */
+func rotate(node: TreeNode?) -> TreeNode? {
+    // 获取节点 node 的平衡因子
+    let balanceFactor = balanceFactor(node: node)
+    // 左偏树
+    if balanceFactor > 1 {
+        if self.balanceFactor(node: node?.left) >= 0 {
+            // 右旋
+            return rightRotate(node: node)
+        } else {
+            // 先左旋后右旋
+            node?.left = leftRotate(node: node?.left)
+            return rightRotate(node: node)
+        }
+    }
+    // 右偏树
+    if balanceFactor < -1 {
+        if self.balanceFactor(node: node?.right) <= 0 {
+            // 左旋
+            return leftRotate(node: node)
+        } else {
+            // 先右旋后左旋
+            node?.right = rightRotate(node: node?.right)
+            return leftRotate(node: node)
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node
+}
+
    +
    +
    +
    avl_tree.js
    /* 执行旋转操作，使该子树重新恢复平衡 */
+#rotate(node) {
+    // 获取节点 node 的平衡因子
+    const balanceFactor = this.balanceFactor(node);
+    // 左偏树
+    if (balanceFactor > 1) {
+        if (this.balanceFactor(node.left) >= 0) {
+            // 右旋
+            return this.#rightRotate(node);
+        } else {
+            // 先左旋后右旋
+            node.left = this.#leftRotate(node.left);
+            return this.#rightRotate(node);
+        }
+    }
+    // 右偏树
+    if (balanceFactor < -1) {
+        if (this.balanceFactor(node.right) <= 0) {
+            // 左旋
+            return this.#leftRotate(node);
+        } else {
+            // 先右旋后左旋
+            node.right = this.#rightRotate(node.right);
+            return this.#leftRotate(node);
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node;
+}
+
    +
    +
    +
    avl_tree.ts
    /* 执行旋转操作，使该子树重新恢复平衡 */
+rotate(node: TreeNode): TreeNode {
+    // 获取节点 node 的平衡因子
+    const balanceFactor = this.balanceFactor(node);
+    // 左偏树
+    if (balanceFactor > 1) {
+        if (this.balanceFactor(node.left) >= 0) {
+            // 右旋
+            return this.rightRotate(node);
+        } else {
+            // 先左旋后右旋
+            node.left = this.leftRotate(node.left);
+            return this.rightRotate(node);
+        }
+    }
+    // 右偏树
+    if (balanceFactor < -1) {
+        if (this.balanceFactor(node.right) <= 0) {
+            // 左旋
+            return this.leftRotate(node);
+        } else {
+            // 先右旋后左旋
+            node.right = this.rightRotate(node.right);
+            return this.leftRotate(node);
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node;
+}
+
    +
    +
    +
    avl_tree.dart
    /* 执行旋转操作，使该子树重新恢复平衡 */
+TreeNode? rotate(TreeNode? node) {
+  // 获取节点 node 的平衡因子
+  int factor = balanceFactor(node);
+  // 左偏树
+  if (factor > 1) {
+    if (balanceFactor(node!.left) >= 0) {
+      // 右旋
+      return rightRotate(node);
+    } else {
+      // 先左旋后右旋
+      node.left = leftRotate(node.left);
+      return rightRotate(node);
+    }
+  }
+  // 右偏树
+  if (factor < -1) {
+    if (balanceFactor(node!.right) <= 0) {
+      // 左旋
+      return leftRotate(node);
+    } else {
+      // 先右旋后左旋
+      node.right = rightRotate(node.right);
+      return leftRotate(node);
+    }
+  }
+  // 平衡树，无须旋转，直接返回
+  return node;
+}
+
    +
    +
    +
    avl_tree.rs
    /* 执行旋转操作，使该子树重新恢复平衡 */
+fn rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {
+    // 获取节点 node 的平衡因子
+    let balance_factor = Self::balance_factor(node.clone());
+    // 左偏树
+    if balance_factor > 1 {
+        let node = node.unwrap();
+        if Self::balance_factor(node.borrow().left.clone()) >= 0 {
+            // 右旋
+            Self::right_rotate(Some(node))
+        } else {
+            // 先左旋后右旋
+            let left = node.borrow().left.clone();
+            node.borrow_mut().left = Self::left_rotate(left);
+            Self::right_rotate(Some(node))
+        }
+    }
+    // 右偏树
+    else if balance_factor < -1 {
+        let node = node.unwrap();
+        if Self::balance_factor(node.borrow().right.clone()) <= 0 {
+            // 左旋
+            Self::left_rotate(Some(node))
+        } else {
+            // 先右旋后左旋
+            let right = node.borrow().right.clone();
+            node.borrow_mut().right = Self::right_rotate(right);
+            Self::left_rotate(Some(node))
+        }
+    } else {
+        // 平衡树，无须旋转，直接返回
+        node
+    }
+}
+
    +
    +
    +
    avl_tree.c
    /* 执行旋转操作，使该子树重新恢复平衡 */
+TreeNode *rotate(TreeNode *node) {
+    // 获取节点 node 的平衡因子
+    int bf = balanceFactor(node);
+    // 左偏树
+    if (bf > 1) {
+        if (balanceFactor(node->left) >= 0) {
+            // 右旋
+            return rightRotate(node);
+        } else {
+            // 先左旋后右旋
+            node->left = leftRotate(node->left);
+            return rightRotate(node);
+        }
+    }
+    // 右偏树
+    if (bf < -1) {
+        if (balanceFactor(node->right) <= 0) {
+            // 左旋
+            return leftRotate(node);
+        } else {
+            // 先右旋后左旋
+            node->right = rightRotate(node->right);
+            return leftRotate(node);
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node;
+}
+
    +
    +
    +
    avl_tree.kt
    /* 执行旋转操作，使该子树重新恢复平衡 */
+fun rotate(node: TreeNode): TreeNode {
+    // 获取节点 node 的平衡因子
+    val balanceFactor = balanceFactor(node)
+    // 左偏树
+    if (balanceFactor > 1) {
+        if (balanceFactor(node.left) >= 0) {
+            // 右旋
+            return rightRotate(node)
+        } else {
+            // 先左旋后右旋
+            node.left = leftRotate(node.left)
+            return rightRotate(node)
+        }
+    }
+    // 右偏树
+    if (balanceFactor < -1) {
+        if (balanceFactor(node.right) <= 0) {
+            // 左旋
+            return leftRotate(node)
+        } else {
+            // 先右旋后左旋
+            node.right = rightRotate(node.right)
+            return leftRotate(node)
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node
+}
+
    +
    +
    +
    avl_tree.rb
    [class]{AVLTree}-[func]{rotate}
+
    +
    +
    +
    avl_tree.zig
    // 执行旋转操作，使该子树重新恢复平衡
+fn rotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {
+    // 获取节点 node 的平衡因子
+    var balance_factor = self.balanceFactor(node);
+    // 左偏树
+    if (balance_factor > 1) {
+        if (self.balanceFactor(node.?.left) >= 0) {
+            // 右旋
+            return self.rightRotate(node);
+        } else {
+            // 先左旋后右旋
+            node.?.left = self.leftRotate(node.?.left);
+            return self.rightRotate(node);
+        }
+    }
+    // 右偏树
+    if (balance_factor < -1) {
+        if (self.balanceFactor(node.?.right) <= 0) {
+            // 左旋
+            return self.leftRotate(node);
+        } else {
+            // 先右旋后左旋
+            node.?.right = self.rightRotate(node.?.right);
+            return self.leftRotate(node);
+        }
+    }
+    // 平衡树，无须旋转，直接返回
+    return node;
+}
+
    +
    +
    +
    +

    7.5.3   Common operations in AVL trees

    +

    1.   Node insertion

    +

    The node insertion operation in AVL trees is similar to that in binary search trees. The only difference is that after inserting a node in an AVL tree, a series of unbalanced nodes may appear along the path from that node to the root node. Therefore, we need to start from this node and perform rotation operations upwards to restore balance to all unbalanced nodes. The code is as follows:

    +
    +
    +
    +
    avl_tree.py
    def insert(self, val):
+    """插入节点"""
+    self._root = self.insert_helper(self._root, val)
+
+def insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
+    """递归插入节点（辅助方法）"""
+    if node is None:
+        return TreeNode(val)
+    # 1. 查找插入位置并插入节点
+    if val < node.val:
+        node.left = self.insert_helper(node.left, val)
+    elif val > node.val:
+        node.right = self.insert_helper(node.right, val)
+    else:
+        # 重复节点不插入，直接返回
+        return node
+    # 更新节点高度
+    self.update_height(node)
+    # 2. 执行旋转操作，使该子树重新恢复平衡
+    return self.rotate(node)
+
    +
    +
    +
    avl_tree.cpp
    /* 插入节点 */
+void insert(int val) {
+    root = insertHelper(root, val);
+}
+
+/* 递归插入节点（辅助方法） */
+TreeNode *insertHelper(TreeNode *node, int val) {
+    if (node == nullptr)
+        return new TreeNode(val);
+    /* 1. 查找插入位置并插入节点 */
+    if (val < node->val)
+        node->left = insertHelper(node->left, val);
+    else if (val > node->val)
+        node->right = insertHelper(node->right, val);
+    else
+        return node;    // 重复节点不插入，直接返回
+    updateHeight(node); // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.java
    /* 插入节点 */
+void insert(int val) {
+    root = insertHelper(root, val);
+}
+
+/* 递归插入节点（辅助方法） */
+TreeNode insertHelper(TreeNode node, int val) {
+    if (node == null)
+        return new TreeNode(val);
+    /* 1. 查找插入位置并插入节点 */
+    if (val < node.val)
+        node.left = insertHelper(node.left, val);
+    else if (val > node.val)
+        node.right = insertHelper(node.right, val);
+    else
+        return node; // 重复节点不插入，直接返回
+    updateHeight(node); // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.cs
    /* 插入节点 */
+void Insert(int val) {
+    root = InsertHelper(root, val);
+}
+
+/* 递归插入节点（辅助方法） */
+TreeNode? InsertHelper(TreeNode? node, int val) {
+    if (node == null) return new TreeNode(val);
+    /* 1. 查找插入位置并插入节点 */
+    if (val < node.val)
+        node.left = InsertHelper(node.left, val);
+    else if (val > node.val)
+        node.right = InsertHelper(node.right, val);
+    else
+        return node;     // 重复节点不插入，直接返回
+    UpdateHeight(node);  // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = Rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.go
    /* 插入节点 */
+func (t *aVLTree) insert(val int) {
+    t.root = t.insertHelper(t.root, val)
+}
+
+/* 递归插入节点（辅助函数） */
+func (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {
+    if node == nil {
+        return NewTreeNode(val)
+    }
+    /* 1. 查找插入位置并插入节点 */
+    if val < node.Val.(int) {
+        node.Left = t.insertHelper(node.Left, val)
+    } else if val > node.Val.(int) {
+        node.Right = t.insertHelper(node.Right, val)
+    } else {
+        // 重复节点不插入，直接返回
+        return node
+    }
+    // 更新节点高度
+    t.updateHeight(node)
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = t.rotate(node)
+    // 返回子树的根节点
+    return node
+}
+
    +
    +
    +
    avl_tree.swift
    /* 插入节点 */
+func insert(val: Int) {
+    root = insertHelper(node: root, val: val)
+}
+
+/* 递归插入节点（辅助方法） */
+func insertHelper(node: TreeNode?, val: Int) -> TreeNode? {
+    var node = node
+    if node == nil {
+        return TreeNode(x: val)
+    }
+    /* 1. 查找插入位置并插入节点 */
+    if val < node!.val {
+        node?.left = insertHelper(node: node?.left, val: val)
+    } else if val > node!.val {
+        node?.right = insertHelper(node: node?.right, val: val)
+    } else {
+        return node // 重复节点不插入，直接返回
+    }
+    updateHeight(node: node) // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node: node)
+    // 返回子树的根节点
+    return node
+}
+
    +
    +
    +
    avl_tree.js
    /* 插入节点 */
+insert(val) {
+    this.root = this.#insertHelper(this.root, val);
+}
+
+/* 递归插入节点（辅助方法） */
+#insertHelper(node, val) {
+    if (node === null) return new TreeNode(val);
+    /* 1. 查找插入位置并插入节点 */
+    if (val < node.val) node.left = this.#insertHelper(node.left, val);
+    else if (val > node.val)
+        node.right = this.#insertHelper(node.right, val);
+    else return node; // 重复节点不插入，直接返回
+    this.#updateHeight(node); // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = this.#rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.ts
    /* 插入节点 */
+insert(val: number): void {
+    this.root = this.insertHelper(this.root, val);
+}
+
+/* 递归插入节点（辅助方法） */
+insertHelper(node: TreeNode, val: number): TreeNode {
+    if (node === null) return new TreeNode(val);
+    /* 1. 查找插入位置并插入节点 */
+    if (val < node.val) {
+        node.left = this.insertHelper(node.left, val);
+    } else if (val > node.val) {
+        node.right = this.insertHelper(node.right, val);
+    } else {
+        return node; // 重复节点不插入，直接返回
+    }
+    this.updateHeight(node); // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = this.rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.dart
    /* 插入节点 */
+void insert(int val) {
+  root = insertHelper(root, val);
+}
+
+/* 递归插入节点（辅助方法） */
+TreeNode? insertHelper(TreeNode? node, int val) {
+  if (node == null) return TreeNode(val);
+  /* 1. 查找插入位置并插入节点 */
+  if (val < node.val)
+    node.left = insertHelper(node.left, val);
+  else if (val > node.val)
+    node.right = insertHelper(node.right, val);
+  else
+    return node; // 重复节点不插入，直接返回
+  updateHeight(node); // 更新节点高度
+  /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+  node = rotate(node);
+  // 返回子树的根节点
+  return node;
+}
+
    +
    +
    +
    avl_tree.rs
    /* 插入节点 */
+fn insert(&mut self, val: i32) {
+    self.root = Self::insert_helper(self.root.clone(), val);
+}
+
+/* 递归插入节点（辅助方法） */
+fn insert_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {
+    match node {
+        Some(mut node) => {
+            /* 1. 查找插入位置并插入节点 */
+            match {
+                let node_val = node.borrow().val;
+                node_val
+            }
+            .cmp(&val)
+            {
+                Ordering::Greater => {
+                    let left = node.borrow().left.clone();
+                    node.borrow_mut().left = Self::insert_helper(left, val);
+                }
+                Ordering::Less => {
+                    let right = node.borrow().right.clone();
+                    node.borrow_mut().right = Self::insert_helper(right, val);
+                }
+                Ordering::Equal => {
+                    return Some(node); // 重复节点不插入，直接返回
+                }
+            }
+            Self::update_height(Some(node.clone())); // 更新节点高度
+
+            /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+            node = Self::rotate(Some(node)).unwrap();
+            // 返回子树的根节点
+            Some(node)
+        }
+        None => Some(TreeNode::new(val)),
+    }
+}
+
    +
    +
    +
    avl_tree.c
    /* 插入节点 */
+void insert(AVLTree *tree, int val) {
+    tree->root = insertHelper(tree->root, val);
+}
+
+/* 递归插入节点（辅助函数） */
+TreeNode *insertHelper(TreeNode *node, int val) {
+    if (node == NULL) {
+        return newTreeNode(val);
+    }
+    /* 1. 查找插入位置并插入节点 */
+    if (val < node->val) {
+        node->left = insertHelper(node->left, val);
+    } else if (val > node->val) {
+        node->right = insertHelper(node->right, val);
+    } else {
+        // 重复节点不插入，直接返回
+        return node;
+    }
+    // 更新节点高度
+    updateHeight(node);
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.kt
    /* 插入节点 */
+fun insert(value: Int) {
+    root = insertHelper(root, value)
+}
+
+/* 递归插入节点（辅助方法） */
+fun insertHelper(n: TreeNode?, value: Int): TreeNode {
+    if (n == null)
+        return TreeNode(value)
+    var node = n
+    /* 1. 查找插入位置并插入节点 */
+    if (value < node.value) node.left = insertHelper(node.left, value)
+    else if (value > node.value) node.right = insertHelper(node.right, value)
+    else return node // 重复节点不插入，直接返回
+
+    updateHeight(node) // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node)
+    // 返回子树的根节点
+    return node
+}
+
    +
    +
    +
    avl_tree.rb
    [class]{AVLTree}-[func]{insert}
+
+[class]{AVLTree}-[func]{insert_helper}
+
    +
    +
    +
    avl_tree.zig
    // 插入节点
+fn insert(self: *Self, val: T) !void {
+    self.root = (try self.insertHelper(self.root, val)).?;
+}
+
+// 递归插入节点（辅助方法）
+fn insertHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) !?*inc.TreeNode(T) {
+    var node = node_;
+    if (node == null) {
+        var tmp_node = try self.mem_allocator.create(inc.TreeNode(T));
+        tmp_node.init(val);
+        return tmp_node;
+    }
+    // 1. 查找插入位置并插入节点
+    if (val < node.?.val) {
+        node.?.left = try self.insertHelper(node.?.left, val);
+    } else if (val > node.?.val) {
+        node.?.right = try self.insertHelper(node.?.right, val);
+    } else {
+        return node;            // 重复节点不插入，直接返回
+    }
+    self.updateHeight(node);    // 更新节点高度
+    // 2. 执行旋转操作，使该子树重新恢复平衡
+    node = self.rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    +

    2.   Node removal

    +

    Similarly, based on the method of removing nodes in binary search trees, rotation operations need to be performed from the bottom up to restore balance to all unbalanced nodes. The code is as follows:

    +
    +
    +
    +
    avl_tree.py
    def remove(self, val: int):
+    """删除节点"""
+    self._root = self.remove_helper(self._root, val)
+
+def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
+    """递归删除节点（辅助方法）"""
+    if node is None:
+        return None
+    # 1. 查找节点并删除
+    if val < node.val:
+        node.left = self.remove_helper(node.left, val)
+    elif val > node.val:
+        node.right = self.remove_helper(node.right, val)
+    else:
+        if node.left is None or node.right is None:
+            child = node.left or node.right
+            # 子节点数量 = 0 ，直接删除 node 并返回
+            if child is None:
+                return None
+            # 子节点数量 = 1 ，直接删除 node
+            else:
+                node = child
+        else:
+            # 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            temp = node.right
+            while temp.left is not None:
+                temp = temp.left
+            node.right = self.remove_helper(node.right, temp.val)
+            node.val = temp.val
+    # 更新节点高度
+    self.update_height(node)
+    # 2. 执行旋转操作，使该子树重新恢复平衡
+    return self.rotate(node)
+
    +
    +
    +
    avl_tree.cpp
    /* 删除节点 */
+void remove(int val) {
+    root = removeHelper(root, val);
+}
+
+/* 递归删除节点（辅助方法） */
+TreeNode *removeHelper(TreeNode *node, int val) {
+    if (node == nullptr)
+        return nullptr;
+    /* 1. 查找节点并删除 */
+    if (val < node->val)
+        node->left = removeHelper(node->left, val);
+    else if (val > node->val)
+        node->right = removeHelper(node->right, val);
+    else {
+        if (node->left == nullptr || node->right == nullptr) {
+            TreeNode *child = node->left != nullptr ? node->left : node->right;
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if (child == nullptr) {
+                delete node;
+                return nullptr;
+            }
+            // 子节点数量 = 1 ，直接删除 node
+            else {
+                delete node;
+                node = child;
+            }
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            TreeNode *temp = node->right;
+            while (temp->left != nullptr) {
+                temp = temp->left;
+            }
+            int tempVal = temp->val;
+            node->right = removeHelper(node->right, temp->val);
+            node->val = tempVal;
+        }
+    }
+    updateHeight(node); // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.java
    /* 删除节点 */
+void remove(int val) {
+    root = removeHelper(root, val);
+}
+
+/* 递归删除节点（辅助方法） */
+TreeNode removeHelper(TreeNode node, int val) {
+    if (node == null)
+        return null;
+    /* 1. 查找节点并删除 */
+    if (val < node.val)
+        node.left = removeHelper(node.left, val);
+    else if (val > node.val)
+        node.right = removeHelper(node.right, val);
+    else {
+        if (node.left == null || node.right == null) {
+            TreeNode child = node.left != null ? node.left : node.right;
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if (child == null)
+                return null;
+            // 子节点数量 = 1 ，直接删除 node
+            else
+                node = child;
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            TreeNode temp = node.right;
+            while (temp.left != null) {
+                temp = temp.left;
+            }
+            node.right = removeHelper(node.right, temp.val);
+            node.val = temp.val;
+        }
+    }
+    updateHeight(node); // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.cs
    /* 删除节点 */
+void Remove(int val) {
+    root = RemoveHelper(root, val);
+}
+
+/* 递归删除节点（辅助方法） */
+TreeNode? RemoveHelper(TreeNode? node, int val) {
+    if (node == null) return null;
+    /* 1. 查找节点并删除 */
+    if (val < node.val)
+        node.left = RemoveHelper(node.left, val);
+    else if (val > node.val)
+        node.right = RemoveHelper(node.right, val);
+    else {
+        if (node.left == null || node.right == null) {
+            TreeNode? child = node.left ?? node.right;
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if (child == null)
+                return null;
+            // 子节点数量 = 1 ，直接删除 node
+            else
+                node = child;
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            TreeNode? temp = node.right;
+            while (temp.left != null) {
+                temp = temp.left;
+            }
+            node.right = RemoveHelper(node.right, temp.val!.Value);
+            node.val = temp.val;
+        }
+    }
+    UpdateHeight(node);  // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = Rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.go
    /* 删除节点 */
+func (t *aVLTree) remove(val int) {
+    t.root = t.removeHelper(t.root, val)
+}
+
+/* 递归删除节点（辅助函数） */
+func (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {
+    if node == nil {
+        return nil
+    }
+    /* 1. 查找节点并删除 */
+    if val < node.Val.(int) {
+        node.Left = t.removeHelper(node.Left, val)
+    } else if val > node.Val.(int) {
+        node.Right = t.removeHelper(node.Right, val)
+    } else {
+        if node.Left == nil || node.Right == nil {
+            child := node.Left
+            if node.Right != nil {
+                child = node.Right
+            }
+            if child == nil {
+                // 子节点数量 = 0 ，直接删除 node 并返回
+                return nil
+            } else {
+                // 子节点数量 = 1 ，直接删除 node
+                node = child
+            }
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            temp := node.Right
+            for temp.Left != nil {
+                temp = temp.Left
+            }
+            node.Right = t.removeHelper(node.Right, temp.Val.(int))
+            node.Val = temp.Val
+        }
+    }
+    // 更新节点高度
+    t.updateHeight(node)
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = t.rotate(node)
+    // 返回子树的根节点
+    return node
+}
+
    +
    +
    +
    avl_tree.swift
    /* 删除节点 */
+func remove(val: Int) {
+    root = removeHelper(node: root, val: val)
+}
+
+/* 递归删除节点（辅助方法） */
+func removeHelper(node: TreeNode?, val: Int) -> TreeNode? {
+    var node = node
+    if node == nil {
+        return nil
+    }
+    /* 1. 查找节点并删除 */
+    if val < node!.val {
+        node?.left = removeHelper(node: node?.left, val: val)
+    } else if val > node!.val {
+        node?.right = removeHelper(node: node?.right, val: val)
+    } else {
+        if node?.left == nil || node?.right == nil {
+            let child = node?.left ?? node?.right
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if child == nil {
+                return nil
+            }
+            // 子节点数量 = 1 ，直接删除 node
+            else {
+                node = child
+            }
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            var temp = node?.right
+            while temp?.left != nil {
+                temp = temp?.left
+            }
+            node?.right = removeHelper(node: node?.right, val: temp!.val)
+            node?.val = temp!.val
+        }
+    }
+    updateHeight(node: node) // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node: node)
+    // 返回子树的根节点
+    return node
+}
+
    +
    +
    +
    avl_tree.js
    /* 删除节点 */
+remove(val) {
+    this.root = this.#removeHelper(this.root, val);
+}
+
+/* 递归删除节点（辅助方法） */
+#removeHelper(node, val) {
+    if (node === null) return null;
+    /* 1. 查找节点并删除 */
+    if (val < node.val) node.left = this.#removeHelper(node.left, val);
+    else if (val > node.val)
+        node.right = this.#removeHelper(node.right, val);
+    else {
+        if (node.left === null || node.right === null) {
+            const child = node.left !== null ? node.left : node.right;
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if (child === null) return null;
+            // 子节点数量 = 1 ，直接删除 node
+            else node = child;
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            let temp = node.right;
+            while (temp.left !== null) {
+                temp = temp.left;
+            }
+            node.right = this.#removeHelper(node.right, temp.val);
+            node.val = temp.val;
+        }
+    }
+    this.#updateHeight(node); // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = this.#rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.ts
    /* 删除节点 */
+remove(val: number): void {
+    this.root = this.removeHelper(this.root, val);
+}
+
+/* 递归删除节点（辅助方法） */
+removeHelper(node: TreeNode, val: number): TreeNode {
+    if (node === null) return null;
+    /* 1. 查找节点并删除 */
+    if (val < node.val) {
+        node.left = this.removeHelper(node.left, val);
+    } else if (val > node.val) {
+        node.right = this.removeHelper(node.right, val);
+    } else {
+        if (node.left === null || node.right === null) {
+            const child = node.left !== null ? node.left : node.right;
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if (child === null) {
+                return null;
+            } else {
+                // 子节点数量 = 1 ，直接删除 node
+                node = child;
+            }
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            let temp = node.right;
+            while (temp.left !== null) {
+                temp = temp.left;
+            }
+            node.right = this.removeHelper(node.right, temp.val);
+            node.val = temp.val;
+        }
+    }
+    this.updateHeight(node); // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = this.rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.dart
    /* 删除节点 */
+void remove(int val) {
+  root = removeHelper(root, val);
+}
+
+/* 递归删除节点（辅助方法） */
+TreeNode? removeHelper(TreeNode? node, int val) {
+  if (node == null) return null;
+  /* 1. 查找节点并删除 */
+  if (val < node.val)
+    node.left = removeHelper(node.left, val);
+  else if (val > node.val)
+    node.right = removeHelper(node.right, val);
+  else {
+    if (node.left == null || node.right == null) {
+      TreeNode? child = node.left ?? node.right;
+      // 子节点数量 = 0 ，直接删除 node 并返回
+      if (child == null)
+        return null;
+      // 子节点数量 = 1 ，直接删除 node
+      else
+        node = child;
+    } else {
+      // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+      TreeNode? temp = node.right;
+      while (temp!.left != null) {
+        temp = temp.left;
+      }
+      node.right = removeHelper(node.right, temp.val);
+      node.val = temp.val;
+    }
+  }
+  updateHeight(node); // 更新节点高度
+  /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+  node = rotate(node);
+  // 返回子树的根节点
+  return node;
+}
+
    +
    +
    +
    avl_tree.rs
    /* 删除节点 */
+fn remove(&self, val: i32) {
+    Self::remove_helper(self.root.clone(), val);
+}
+
+/* 递归删除节点（辅助方法） */
+fn remove_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {
+    match node {
+        Some(mut node) => {
+            /* 1. 查找节点并删除 */
+            if val < node.borrow().val {
+                let left = node.borrow().left.clone();
+                node.borrow_mut().left = Self::remove_helper(left, val);
+            } else if val > node.borrow().val {
+                let right = node.borrow().right.clone();
+                node.borrow_mut().right = Self::remove_helper(right, val);
+            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {
+                let child = if node.borrow().left.is_some() {
+                    node.borrow().left.clone()
+                } else {
+                    node.borrow().right.clone()
+                };
+                match child {
+                    // 子节点数量 = 0 ，直接删除 node 并返回
+                    None => {
+                        return None;
+                    }
+                    // 子节点数量 = 1 ，直接删除 node
+                    Some(child) => node = child,
+                }
+            } else {
+                // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+                let mut temp = node.borrow().right.clone().unwrap();
+                loop {
+                    let temp_left = temp.borrow().left.clone();
+                    if temp_left.is_none() {
+                        break;
+                    }
+                    temp = temp_left.unwrap();
+                }
+                let right = node.borrow().right.clone();
+                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);
+                node.borrow_mut().val = temp.borrow().val;
+            }
+            Self::update_height(Some(node.clone())); // 更新节点高度
+
+            /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+            node = Self::rotate(Some(node)).unwrap();
+            // 返回子树的根节点
+            Some(node)
+        }
+        None => None,
+    }
+}
+
    +
    +
    +
    avl_tree.c
    /* 删除节点 */
+// 由于引入了 stdio.h ，此处无法使用 remove 关键词
+void removeItem(AVLTree *tree, int val) {
+    TreeNode *root = removeHelper(tree->root, val);
+}
+
+/* 递归删除节点（辅助函数） */
+TreeNode *removeHelper(TreeNode *node, int val) {
+    TreeNode *child, *grandChild;
+    if (node == NULL) {
+        return NULL;
+    }
+    /* 1. 查找节点并删除 */
+    if (val < node->val) {
+        node->left = removeHelper(node->left, val);
+    } else if (val > node->val) {
+        node->right = removeHelper(node->right, val);
+    } else {
+        if (node->left == NULL || node->right == NULL) {
+            child = node->left;
+            if (node->right != NULL) {
+                child = node->right;
+            }
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if (child == NULL) {
+                return NULL;
+            } else {
+                // 子节点数量 = 1 ，直接删除 node
+                node = child;
+            }
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            TreeNode *temp = node->right;
+            while (temp->left != NULL) {
+                temp = temp->left;
+            }
+            int tempVal = temp->val;
+            node->right = removeHelper(node->right, temp->val);
+            node->val = tempVal;
+        }
+    }
+    // 更新节点高度
+    updateHeight(node);
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    avl_tree.kt
    /* 删除节点 */
+fun remove(value: Int) {
+    root = removeHelper(root, value)
+}
+
+/* 递归删除节点（辅助方法） */
+fun removeHelper(n: TreeNode?, value: Int): TreeNode? {
+    var node = n ?: return null
+    /* 1. 查找节点并删除 */
+    if (value < node.value) node.left = removeHelper(node.left, value)
+    else if (value > node.value) node.right = removeHelper(node.right, value)
+    else {
+        if (node.left == null || node.right == null) {
+            val child = if (node.left != null) node.left else node.right
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if (child == null) return null
+            else node = child
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            var temp = node.right
+            while (temp!!.left != null) {
+                temp = temp.left
+            }
+            node.right = removeHelper(node.right, temp.value)
+            node.value = temp.value
+        }
+    }
+    updateHeight(node) // 更新节点高度
+    /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+    node = rotate(node)
+    // 返回子树的根节点
+    return node
+}
+
    +
    +
    +
    avl_tree.rb
    [class]{AVLTree}-[func]{remove}
+
+[class]{AVLTree}-[func]{remove_helper}
+
    +
    +
    +
    avl_tree.zig
    // 删除节点
+fn remove(self: *Self, val: T) void {
+   self.root = self.removeHelper(self.root, val).?;
+}
+
+// 递归删除节点（辅助方法）
+fn removeHelper(self: *Self, node_: ?*inc.TreeNode(T), val: T) ?*inc.TreeNode(T) {
+    var node = node_;
+    if (node == null) return null;
+    // 1. 查找节点并删除
+    if (val < node.?.val) {
+        node.?.left = self.removeHelper(node.?.left, val);
+    } else if (val > node.?.val) {
+        node.?.right = self.removeHelper(node.?.right, val);
+    } else {
+        if (node.?.left == null or node.?.right == null) {
+            var child = if (node.?.left != null) node.?.left else node.?.right;
+            // 子节点数量 = 0 ，直接删除 node 并返回
+            if (child == null) {
+                return null;
+            // 子节点数量 = 1 ，直接删除 node
+            } else {
+                node = child;
+            }
+        } else {
+            // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
+            var temp = node.?.right;
+            while (temp.?.left != null) {
+                temp = temp.?.left;
+            }
+            node.?.right = self.removeHelper(node.?.right, temp.?.val);
+            node.?.val = temp.?.val;
+        }
+    }
+    self.updateHeight(node); // 更新节点高度
+    // 2. 执行旋转操作，使该子树重新恢复平衡
+    node = self.rotate(node);
+    // 返回子树的根节点
+    return node;
+}
+
    +
    +
    +
    + +

    The node search operation in AVL trees is consistent with that in binary search trees and will not be detailed here.

    +

    7.5.4   Typical applications of AVL trees

    +
      +
    • Organizing and storing large amounts of data, suitable for scenarios with high-frequency searches and low-frequency intertions and removals.
      • +
    • Used to build index systems in databases.
      • +
    • Red-black trees are also a common type of balanced binary search tree. Compared to AVL trees, red-black trees have more relaxed balancing conditions, require fewer rotations for node insertion and removal, and have a higher average efficiency for node addition and removal operations.
      • +
    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_tree/binary_search_tree.assets/binary_search_tree.png b/en/chapter_tree/binary_search_tree.assets/binary_search_tree.png new file mode 100644 index 0000000000000000000000000000000000000000..316b33089250d0898a77564791f679cb1b05820c GIT binary patch literal 11901 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree.assets/bst_inorder_traversal.png b/en/chapter_tree/binary_search_tree.assets/bst_inorder_traversal.png new file mode 100644 index 0000000000000000000000000000000000000000..9f787470f65ba10187aa17a909c401b7e8035bf1 GIT binary patch literal 31242 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 z zdm(vB$PC3CRw|Yl3ZtrE5N1bs7Pg2TTVRrZAr1chpU&PYDy}A27@c8ohu|*3g9LYX zcY;H32<|?(OK^Ah;6VZecL;++aQEQ;&v({&y6b1(p6onx~jTcZCVUH z``sez!YVUyimJpXap!M4VU#=(tllb&M9w;#j%oGGwm) zx-5pAe#WNAaZ;p}7|7a3lhW_Zx6Fc1x4XY@-t^*kr$cj%$0)f?x}X!ve?sG8$A`Kl zBVP%Ll4PwGGN?Om!?Mlg*eT+?9hanXT0+(|krY;hxZ=Fto=btVmNtmbQ?*K<|R3P{5hTLu0$rsbxkA_R2#sRXm4 zSm-0^8?blaI5zVa4a(jEhMnsvk7kIl5NJ(Q=WQi!K43JDiQ`^f5RtTYU>Ohy|0&PY z+WPiX7aKu2U(L=Omyu^ufi}gtM>C)NnVvI7 ztxsj~mEZn%m`0;5n;^i}idnY`w-br5!S>C=1BCIh}ucC zvl|O`)#hS!XtA-_d!-?zC4(PK0bVxOtT)QmDwvr}$p~iy*gH^J(tmoJx$eF9N!N~h6Y0jJEo$>nvsKjhQKqEjXU+4dNES8^qSC@u?Q}e?k3NhdKH??y*Xw_u+(DVWa@htX;8R3lnh^xP$tfF72qwc`HANg8bmKO5t ziZm7HAAzaYvkkRN`xK?K8Cy&|Z4(I2gg$42WNV^pVgRF0xrPLzXXMJAHN6J4RS-F zFuZw)59HAm@ZQ!C!L&FO{)RJC?5~e@M6=Cl)=mqk1urrM}ssQ}z0ysodOsQnwO<780(bpOpjO7~k>D+P zTQ~&aKff^VDBSU?cmH-ypm)4h*6LpS*`yZAQJfMMkne%$@{0l6cKzRGEN}XH3LQQcQq^ifg#}Hg-4|3; zLDOj)yr3q}&U=UFhKO&C4#0(kJ3{Bg&p?k$;+X+_A>u#S-m-+`Brn_P=UpwoL|P>_6=M=aKk$_+1zR{2 zHtIe8LaB@wp(^-&H>VIcx~!^YcNVo9N`ody5dOHBfdL`p8hT}tS`&IU&ld+TjZH_&mv9-w@ELz4A%@nE|Z@cYb@mLp6Yucn{d z2O6oJuG7-9Th@+m;uOyf#lvcm4OP&d+^BBj?(EW)0p#T)pr0Tpo4K0fC>OEFP2^ zayqB6$Yx@l-qiw=JoI_%{P=KU>acn3RB-%$UikCFg{ZVN6H8qYz+JNx|ELnRsEu>a z`O$?cua&|Aiy?1cJKI^CV^YuZl_!jCLS%ZOGeF+6B0)vN$$K8v#^y1&p&dV(RCmHT zW_4>dTDPuCH&IK!!6XI^xHJA#8%)qtAZ}ReJWrC|Ln^=Lpg*4ng4MKJCNEOk94H&2 zXG6VCK)D#dyM)I3Fxzer2!MmBN}c|q+oicXa4gJ?V4m?lGhwp4>WZa9hgcb%uc6h- zHRNy3Gnu`ky+kW7UN3a>L9Oi2 z3^+u^2eE2;+7zqBsyZ%eW}2i3aozbM8)HJ4`uT>!O7q144?e|$zjTfY`H(kD!OPWl ze74^^pD$IIhz_=&dKf$$SGqn6IZCo%CAfhWy&mE zMZ;s6EGd+17NqfM3nhBDE&o&t>7^SSxy*1{h<=TrBJ7~NkIItw+ic~m8d24+dHa%! z5}xPZu~VLaop9$%XR>^S2KJZoC*qzcxmR*PW+%_B@Qeugd9Xph& znh>FJSJ*D9UU{iXueNH7i;b7TRWUz78pf2K zQYKuB3%WUMjy#h!{og;Ra7ArlQA*Cm_47F`RhY4`*ELweS*YnpZT_;BO67myF3)Rp zBFBf?0BduA9=g8^!Gy%v7|K|DpS^pAH{H;ba>=M?u!vyD#d-RA4%ch#$BQ?W{B0MK zLQ54^3X^KNELS}Oa9YYvzg6j09e$t8=1=Fp+l%ecUd6vYOFa#?*0S`!;Ewl`*q8`U zexzx%{(W&hg6hT7n~+Cf!=CY(vb$VzSCK}*DZ&o(_$ILg<7yd(+Eb^juRa9@iFuFj zvP^isq0>)H4-PUakjNNLlTRvDn;qTHt6@m|(nQL4X{Yj3VQ24%#W!xW0G!Wg9kIuz zyqR=#%H*3v9Z=xzMYue)^YrH$!i|a)>It?jS;91-Lc_NDEC?f+Dk5K1tT#*p+yu5uDLA!h_ckun5=t&0R zu*^t!{f;7E?~0-P6#tK`&@H-XxLaFig|Bag2uYXkSuuF{S8s)eX(Tfk*`B6I^$*V& zBr=a7r@@}3&2gzy@7Gp#HY;Pi1>m@bjB}k^CL}jl2!WM{zN$~!vaRHN{LbH>H zz(IS713zXpLVwmx$2Q+F0cy4im3o z|FS@qjJ};Im(_#_ipaKhYpqQoPSS%cQWHQ?#KQF%18Ry8*3SqP%M5eR=?h@(NNN+Q}PoL6% z46LPPtz>QS@gG%-80{pFv2ZVIbW)hj!O47aXQ4+^SIFhyKLL_Om%16QV)H%ep-k6R zf<;Jai@D|s)M~v~vw@Pk(%_$q#pYx=0TewUM6)Nf{=6VaG(v8`$K7Fs^*m~oP9tIX zOG58$t~ST=j)1-vjETAsG7xsBRNo2)#2!qEd{hsffE^NaV-b z5`(2DL3%6RWNhmy`KZC*A9aSsdJGbdw|&-Z_g@r@{yBij6IQQJPp6S6uk&<&Y%eFE z65R27qZ=IndZ<+rv5W#>C*BPmV=1_C(erbW3u8EF+T6>z2N{gJuNyqW9$7v=tb8%#=80`;37O`%z5sC% zXZ5_QGwlK@AF(=Loq$xo-gj62*qzwh?XRFAyy|pP1n`=_F@D|u^*#LvGxTK-V3>Avc&MqU5;&@0W2^>OLWoLG zrc_l}FR6K_m~mLI(I0Q6ZLN9oFVB8hhemu#9>t2#K|8DD-_KF$_@Mip?%uX8SDZ4jaKJdjq>)>-NYNw<*k8GWGbc_q=i zVAIpK)n-cV92jv{@cn{7!hJ=<4kSan{O}J8%txGWBydo8Z#nT%BdE<1hMd_4&4GBd z%d?wkGu=Gc3S@9KRxs-kuv3jZNiR*U$hyN}mi-6v&>GtWUMPftG(g?FKiu@|XlFX%*4kbr*(PV*z%RXN&(grND zvPk54X4i_LNJth>x2vQ|o^%kr;diYeK4iAtwu6|-?fv4LAShY}^X1|0BlbJMBtvSX zoe;_^dE$d0uTtLI`Hg!GFkbAqoGwM#mi(h#eiMi+IP|w)al=Q@N;w`$l>s`RT4y<; zdz>YjMsYxk3s)e)TL`tm7|6uVq#cVd`j!Ew6~H9XJ%{|3q95V#K3E{0YaZf+^k~%1zWqVAE0aa zsE=oxIaaO}Q#Pe^NyFJXfj4Pq%+$hmf=D3vGJ%ZhyF2fgn>PZwe6bS*$%(S&keA0NzWGj1D; z&tsD-PcuK9@u?OU3WqJ~Brc~E(cwlO#Za~P1CG$Sh5iRPq^-=++-D-dq=xq*PQw@~ z`L=egVA_CP9^=KgWD|bFpumswGiF<{kKeE+*n;$asc^c}J{sq*x4YfE{5(l_7*SNk z;eiuo|IF>s(x|ny*_(R(RLvh&xvW&w&Wa*@!~aP`n!;73AwFKPbJ-I{QA8KLKkeBA$mC+k7AlC2=HkNs=r;{?{{KqFZBzPCY)*x zlgRR8oK%WfWw59`A~iMm4fD{zt|&V)k*v_|oO1tgyf52cvUaIsXMgjMGkYQ(BK#ph33@qy*|M#5(O2N2=4sQf(LoA{gh8=^|oI5eMkY;S9AH+|W~{!w;l zAMrBXKQQ|ZgBn8C+1|X1DOl<$Kx{&^DRRqZBFshL#)Q;f`N@5f-FK-G=0Qs1m8(}H zRgN!5b4A2I!pA(c#1mkML?PJP-42i5>+sup+1DPHTl{1gy958>uUagF}o zjM`(-v!;<@6}GVU0MAKE&2|tE!O9T8P$+br?nbWR%ze(DLzRoWib>>DYyH;(x8`h2 zBVoHPAGcKcwAm$|*@Qs4rG|Evb8){1clOPbS~gty3fH@(WnWK9pOsE5yI09XRLyqx zFWZ$DaY;?xcC5QUBhh9YeY+VC$Y)fu6fKd%UiHWASJxQ$Klc0+K;&a4FCYRpH$ z)*Wfv&Z${bp6>!81S2$~llJ~n_OpplnU-;+u!K45s@YDpusItOmF(v1x4#(FYi6EB zR)bH-c29cc0$VIk|1PgsUvq(C`HHAgpO6UDeL`3N!8r>(C*D9qV(E#}=g^Rtu{_p0 z`#TcHD05Ir5UojYHpu`u;*fz1n{$)05TUz5s+jgcl1&(6p8`luuW2`C>tFlek>2Vi z1zn(m@g$ly=z&oh)*6v^r@o?~RNk_nI3&m38u2EAue-Ef-xIWv@Gin}jnTh5MaFr} z5wuD!#{#^3BmXtw4DiY0C0P|pEX-g$0{jZtiSq=mT2-kFby6gKko(W#Vs82HfFYJJ|gMdV2_!!`wsu1u=Wd5}0FK2~?1kGobdSO5~}X(+y82W|;> z-g)P|jqBSPda9iq5|}S}kbb?-T!D1Ko0!n-2J%CT2V4f@1g{O(dIAitP#Wd0(v#Nm zg2nbY0<0Gwr@2h+PAafel~er|fxVB9I($OD$^HOs#xlH}XwK+pTVU7g-dSZfRVBfX z@p^#%U4C7qaw<7^tmTeXlQvly8V+ZwE3VtIXnXS9O1TKap`H^c*Cg0;AQ89!dx8Kd z4Y*qO%&%0?+W$!e{t0=KzPe{r_YD@bmlH>~vazjb7VBjC6k~RsVEXSj(B)a&;@GqI z$>(HJXG_?N79Fkqf(lyMA;Ill8_Wr~C|F3w6W0fggwL_3ni444%;hyAh=ZP#m}+HR z+RM%f9mx)RVjzce-A~eV=2{{vL~>l~O0^hpUzeI+d33&PXqs6;>!=lf#R?&Ghh5A> z&-uqGPI=V3JD@H4J8=P8lt~HMb#hh<6rc5&tC5mVFdNs>0+cj3zQFs%(0M>vMW{11 zZ*wP1`r3kmbNkHUY0GwF4kXM6b^xt&ZBLuj-_3+lY>cag_*>c=;dL(*SuQwjGqOwt z9qxopt%}$cjoO!T*dXQab`fPBK}By4HBHdH%7)x`o{PMHqerDxPO=0IF%<^yw=8g{ zilcjKZn1?$a4AeSLzKdhsG-?#84AgYchPwmsbY*nA(hE^9{WV=%#Mi} z8apecRc;R3od*#YZ0^fqB-E!8qT!<|!_lIs8gMMC(ItCP{G|~Q_e{Bo))^}hDLHcl z-7oRfWdj{|m18&A5;r$*hGp^m*7w-N(8_6YfB(?S&O}+2tW@hZ`shJ^qwNCGeuzXm z#RJjzNh%cs{d(IxWH-T%9+Mpkg*JhKX)Zf$JKE>$qqh8IfO&=>a|@&MmemnOSKD}TG;E{_80MDX|7I@`BAo7)v@7x)dc4E zq6DLf7DTbbLC)g;}BZ-b1z?coh9OqQmQ6 zqRPk91|3bX>{YZ#ThHIx#mEIp_i+J4W$5)Hx#tm$C8Comf-~*fD(SLa)FYM)6^pJb zkSv?lA7fk^NO6pqG`k^+RCT?$e+)qXgFN{$x8~i z*6EDi*0kFmteP_~$oJ(dWZf{~rpQ{a%A^RgZ^vy^T4j7^5sWKFTW|e**9KmAsQowt*!sDI&3m)?QpndB zIaWS<%Yy7$^~eK>!IB{moqjC&2QNj8dCqDr9Fwgyq(b*4-i2( zgY3FSH9_W+RUlq@AU%)uj~itPq{b>fSL$SzHRhQ+T3KXe(qH67p+m_}BzI4G3oA{R zjE(HHta=}ARW(j9$OFD;-)&tV9IHR`V5elmO z#Gw2>qRS~+%S@LzQfe8_SmF~*Rme=ITFle(4ML$M^yEdq;>t80; z_e%uaN|aTlRp2=7zkH~_Zz032s8slL_o}i`HO~eu7IZf z=1JuF`gV1ge4%47I!bw0Sw0mdRl%_0cc~~BWHZS%rBy0bW8Ao_%z*n={*Q>c4>q{S zNpdq^lVR~mZaHRgo#|PULCdPIbk76_DtqOXN-Z~L3+}_xqN3QhHHNf1Yh*mB?e>bG z;44d>kByZIJQ9HnQ;M~nUe$QV-gmIS>lYYH-WW@byq!`Ri(P{;-+seL*$D?pl7Zw~ z-oCs|L;mICs-J0KFdvcULOl}dtvb!}&k7*{UQHq*euZDWUkayWY`zjLd!vV_fJk<6 zM3LiX61(cir)qE=6>)wKWq+pMA}#hP#l3K?gxHb2 zByzc*(qk`wy$>Li*1$`^YLt%-7(bmhc8c)`NZ%(nvbh zN_6Mp=3V}>j<5V@nV^)CfzP)_MVP678Y*dj+@0T4>Z5HKjG5_!i`xIfWHfy`y;xAg zL66ywh4XRF3Q-du$99=ZmCDGC0^y=rwf`$dqc?MeI!|{Bs^O9o@v{rgm{Dgrf6EUA ziqN5QsG%gNb_|8lPfzDZM zbJ*MNIp`@J&6rV8ON6`;Tl`+7mo0W^Najw-wB@yOM0ozVXjt{1{Fr3;UHeM}Oq*?) z=E$RT)0<*~LdS0eihYT*I90he!8QZEOF*+BDi&jxE>gHDCwC4%?xR--9tg8S;21?z ztzTHha1=&cD)m_cm&yGx)#pxDXN10S!V`vVibtHrs%Fx50( z;QS0%q2y1>b5lci24-mqvCz9b9hA6WSehV9%l2jVP?UkJXBlG|F@P*m7D3ZLX3<8 zvJ`&}^ZS5_@1YiyaLT^bfb`}D_2!RL+ej`4eON({E6Z`@0B&u7nZ;l7P;)Re3$ zh*&*G(5aE9HRJC#8m+tXuDmvS%D<^Z6&wc3EKmDqRS_^&0yel&6tKlUyBDdouqqF8 z9|0!;U!G3wOaN!Yj#X*Aiwq*YF# z6_4nA>H22v<{Gp4jf@CNDZIgGs+A0{9(C^(9~dKkD=-B5kSM~cV%}?Jn;qJaf-hSg zU2JQQ^}gwPr^#mv_KO~bw%LE~xfzO$9ns2~YmC3^x%1;Iqx%9sP3kh~r5Aq# zO|W@RwuUPNjdBdWO-Sd*qNI5Fr>a()HD=R6AT57G^drQT7&Z+ORR8{P0mB@L{1sZS zh52-VZWI~nQEt~>y|g$sK6e28>wCFE_YhP1@9N(`1*vEat8UE87azV}ZflpbFk*JR zu6M;+TLXTB9P3QoMPOdkrZOpUAnG+M!#b`wHFwzCMEJ9pbjkh#08%agC?ziI+5JJ4 z2zlz+5l)4-pl)2Si7WiKR;`q~sFhPBb`U|R)@sY>^OK#0Mg6N`g_T`1Q;O5*7H<Cj!zknsp>fqI*Wxv6B#hy&(+qBW?@Cro$bk|4+m zT~0bHXP^cL>{52w12oupgS=J z+9oh6UU~UhTKW^LnTGY7<5oV75}1hG%ZPu-jzE*PHsyV45W>oA1~i38_~}V?6B7h} zjWlpM<8c*r)p5EsJq18%crGdqkgu(lt|-Rn+B+C*eL470j^LKSR6)(bRj zE>i2{cEKAYoqu>6A-zbv)=oX7&e9FL!@&Bl$Xgymk&eDp@Q3g-pm$Wcrjdx~IA=re z53niQzR+t8-OZI6F9k!;S=<}3kbwO@of5#-(wW$BJ(9KitKj;k zDp-e>sf&tcKyU^{vljhIkY?a&2F;6QJ7f-sa-Md6#Zhg-o=Fm)Yr5&&*7DV%$K9eB zA550DlLN?!ne`C_>mv>#G7Hpn8&DeIJY{FToK~l-K`{|{D!Z6W-HE$}lB7NrIG-^D z+`Qp$#WTxzZ(EL_4Z75R|4Y3yxlUN##KT-GTnTdO342oauvWMi5b&H{(Igmhe%Sb& z=qg^TfvFhEdt>fc7~b!Pg&4jOFDz$tN6yz@4BiJP%U`w|u zAmv@C#Z2Z%+h3m^t*xf1a<^s;LsYX~ZG1|57BM_GZlRk(?4Gnb-*S9=xUkZpMmqED z%-Helbmyo%PKK#z@}uM3UC$yM<5g#(nN z9Tg-wvS|aNIQ#@eV%U`YKRb?XNg0b`3e4UB_o#%?(1puKe?&?>do);Qn<2jj)bpnc zc)U9NAG@8$0`64caK69hyxZb^qIzBz5j`-KG)H=tPBy_>UIZ4<_E9ya3s4ZjM2{Fv zgAG|FB@I}AL^PvOQTcYjRsf<$$PiRxz*LRpz7)s>k*61Akse}_l0YcLaB@VeelL0E ztRYXyuS+XOVlaUzF!WSCq`f5dS1BO&*xu1>WW4whi5kh@+3-tF!;}H3(D&2CqFsAd zuzEEz4QwSLslE;!utmmktj=CIqFBqnr(nLEGVhM=SrAvC+i+nic*|zpBOBZ|Pc29R zBYwdO{zn5c_nfm&{meS23~LF;K#-;_q6z*h?_LAIapx zkVB<2R7frwqvqwn8$zdu;?)e#yIWrMACp&Z0B=*ab~Y%?aW4D_Fp>#Z>ey$_tr1~` zWepLqh4khT2dql=eQz;jZI$NFxFAx0{-0w_+D72F}sKzHrI%Li0KOK zWh8?a%Q8W)h6%P8Nv~HK2O^Bu6QxM~HXS{f>Ypb}1|sf%0&5EU03i29HN)!Vt92zH zZH<2%)71x^{s}$+krL1-Z@DaGE7IQ5O#$)bq^~%j`slq--q&@28cyDO-Q)xN3ths> z@dvU=mwl4eHORo`pNV%m+RLF08@C*>z8XMkmk;K!0j?i|!U?_DLu23h(>5GiUVcGx zW)kUjAre?N)Bl0J>$->TeoBj=*9)`v1Kl7}YY~)74p=s$0~%BjumV>^^N4}K0)NES z@lzQR>ewj^Zp^(iLDXQuv?*SY79ftp=qoXF3<$~qdKw+%J$(KM5(*=3=5&eGh>_79 z(D=H%mRC+uT|;$1qEk2Ve#NSetaQmj0ht*p<4=v%5EB~mr}uL zKK_W%%w~WOT%0x-q33i+A-%8sk}YKXqb#kk98k5+zhpt9HlSY#(^*Q)yD#^E`}H|t?ti|2AAX0? ziBS?n_;0BF1O%i*VY0xf0&%eZUtJ_&H=GmWdq2qOG}PrPo6M>Cf;X^@{^mzYVe!_O z+T;ZMquWMsuF?D<4SX5;yB<=8HRMckk&vHj(6Lt8|8qCobw-pExHnQnMo<`%geb$f zn`6+l(lUvOWf;nD$#PE0A1ZoKQ>ZYkO!EcN?PUGYqx^2L?Cj>9LO3F12S5M%JWxE6 z8I)m8m`817qLuIaMW-}O#`y-_ue@vUw?^9M@|j+PDS0#6@dx&`F@;cBKp5t`Fc=x* z5(UHff+O>J6gHcnq?Hm(+WLnW#+qp&U`R6^e;g37#mDwlR2zmqbP3T85-d}=SC6L@ zs3if^tjVO@|5|bv^RnKvz8)v(ao@8pVzQoy&JByXc zLIH{qYJ08LNT=}d=ZA73P7fO8|Uk_^qVeKT}F|oIHml6 zv@$73Q6o;a=Tcr0q(SDf$)rn`YjN07WeP zU`u7Y5q2NfPzvVDGlw)oBD$Me>v*!2!lavA7J!>G?x+ca$+rM9y}B$|Rm2|_fMNqJ zeb`GJ1(_Itv|Y`1Ik0QP5M@&+IO$_VFYf)zxQRS+!iQ_}beVL;V}nCb1%b2!Uhk*n zf0aQ1?Jc7Jp#>guFzEn=n8x^22k5szg@%K+NaKi>5Z9n+t^^MxZ5$U=FWE=HWXPrV z%1a*ZsGKeJa{Jrs$&OOcpPBL>6}T^|aSRV00a(4tappw$sH$zKn_MVThV`+$L!4kQ zB@e*vp-VF?M$;VBy`{$K#XdO;9WSH>;)uVD1IQ{Aify11Q+{(Ip6F^R!z*ijhoBGh zoOOIIyg3LBd=0{Yi(|KWV)!PD{nt|lL^w9?XHhFDs2m>BfvDG@FJ(oo8E=n#z4dm$ zwft`#a8f@GfRd~5U){CqzwDdlgnU)fnHAh0cLIp~xWG?Q{GUO@0zS|&J#bonL=GVA zjcEIhyFvTKU4|_50`5H1+dz#u!(v~pG?jPLlmSz8RWwg!t4dXd0t_*9A&kY`zJP0p zO8iR9u?27lq->u4MSbl-4~|?m0x0|-PMaNfF*soQ1hPhjkHQmhDz%0ORV@0U{ipm1 zAYKx!>P61a?q+G<`3YdA9b9_tUbpW-4~a;Q!5kQ0xQduE5#cZ|p~uGg?K?(#hy2v} z#^?7Q-!i}%ffuZA@)K7X@oEXMe>mD-zOXDB@7bGJhNflp*anJ}bNbNLX-e?huF*-< z^8WNNW=$SY%$eP*N|$Uu(e*L&B2E{45W54_7e{_ep6{Kp~jnuV83I-0x0E~>hKJnxK+Aa&K*tqKss_1lFL@4sW`PYtSLZ^F> zW0VEwG~%BQ@wDUJzuGOhX~n zjW{qeBnXBJ*KFuB-;Nu2e*$aSMBL&dJwS@>nv|!xEP*6fHbGtdK$G?$H`Mkj_=3w; zgsy^Wtu@SE{f>_Rz@-66)~dE-&87rW zUdTFn*IkCk!`YWM>%99AF}PmkE&k>8pbM7HkkW4Rt^H4wP|Y224Wa>yBO+~nxXSex zpoMM>6-4n+R5%s(sG<0sANF4-g~LZXR748ZZ;Wsh%M8sxdbCY6QJ1nr089%|5J=x0 z3|nx6HG>B0wO+Y{gjqof1gZMKe+IzRDm1(Sp%)ay89mWgkY1a~Gpnjz?=2kcq2ead zJDBz0+>spQsTBCX(*+D)CyM{M-F;s{gdPa`|M&Mh@3oj8c~Fhyy)@nl1GY=BPh4__ zN})lGxGhnXF=iBd?Kh6D_Ck_{q93Xchn`~cbcp#nx5wur$p{*|DT34U}-T>u-P34pqI+RH8muY{i z*ExRfbo-cRgLq4xkG)z4(`8!f`SCr5+%9OynfES}Pj{-b>v#SM*Rxy&SOG4{1me`P z$gth3G0_YDEL`MQYLYM|aKm3>o_OWNTSjy_x^jt?&vXk_3Dk^hlpbFY9Z=KVs(VkP z0sa=x)TJFKCuxlY15c^#v{rRUC+p<7;TvWnba_a_e$k`xw;l1`&q^;>y5P-^yXWXt ze?932_WJU+#6jEwNQ)LP0OeQ$M@bfO%EX{0Tejya4275Sl}|*h20f|gamc@K zJnK|l=pe++voT)(6q^8ph&W)^5vMR36b%yx)9;85BOWVfUa+?OSVXN$QOvRnX&wOh z0;6-`c=k8&8*CGQ!t@q^mY-Qf&(9x;+_p?4YEnIyd91p?RofUG0NtwH_j zsDpK%8XmKEbzWUtwqKf!c<*Eys8|N{8=_2u2>2d%Ya&oCD>&Q7xH4$z7zR&yDVo)f z8yGp5o^O@9WhCS%&BlvzUCcb`oOA<16I5NnpEcIfDXp1ZxyQc;` z3=8^cB;@*l!0$@ViyC7fGVuFMAz4fl@c*uL|Bt6&$Fn}l|C)je-s}BM|M$>Z6TFqc VYq3b;4wV0z%SkCq)`^=0{~y2CIRpRz literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree.assets/bst_insert.png b/en/chapter_tree/binary_search_tree.assets/bst_insert.png new file mode 100644 index 0000000000000000000000000000000000000000..7b999e2750f21d8b57fc4d9791acd6d3c60d3c45 GIT binary patch literal 25863 zcmbTcRa9Hy+BKTs6fecyp~VSS+G4>S3dP;sind767MBKhFYfM6aCZ;x?mg+=-*?V9 zcmMcvla)v2oR7RoRz`j*D@tL#B7Fq_0I+1F!KwfNGW-%@91RivbeF?s3IHGil;uB5 z{QdhE27~=*@)yZF{Q2{zkdTml&|1fGM|*qw`pH`Ma8~%>Wya+7*xrL<%Nd*E$n*0v zfj`vE$*H@$`|;^sD+wyx_mEG#TCBI5AyaBy&Nb8~ZfX=!F=rlh2#zrWw8 zqHbknWoiBP@ahl@1~)V`%+JrqES^4MBpP-h&?Ck9Q z{r$|040m^Tl|K`Ak1xW)!gF(T(a=k)+JpMJy7csPGcz+;S=qSm*rvwD>Y1vuvopx( zRcLES%gk@Z*OR5sHdmr@b103y1KQsb!TU1@!XAf z%*OrWeLw8JWwAMJ;_CbN?Tx97L#L5bV)e~w1CM}PSH4{t#Oiv#A5AJxl`6|AOm zb94Rt{HAxOrIV);3U-qUmb6@Ect4N!t@lkWUiXh*{AoCvS=@5_wJ5AN-adG4;j^HZ zJELEHA{0N_z1n5yFC6QZ{=(4dgbtHP-bBF+C^k0tg8K_ zvT5~4{CsMDYDz=0Pt#^x>q2=~d34628KluRt}F%;6V<)r9hsb%mFR)lGynh?b;*E5 zKYJ`5&2!nj5heE95R5Ee(!+K>{L%YEGZ$A)7oX-;{(H@wpdV;%qO4$K(MP{dzS_S% zqwVHyTa62GJYti}E0?a9ohS0w-0}$UGxmS}@Vidfl~4)q-^w1SLaN{$J>+jI85c1W z(w#0JxNNa8g4D{PBh`t_&Nv7R(c{j4yQlT-=I>w+^F)}}U66QztOAx$c9P_%D+U(_ zuI~@Onjjc7nT)w8ZLsmMb+o72PdV> z?ggzk7LT9 z4Lm$G?$q;QSb@()hPf)yqev?7%VT`b-gWmp%AqpFtDyc1{n^(ZEo%zNb_WN-^N)Ho ze^&&M1Fzjl@x1p*8D~@h1>TneVWG{p+6uBGOF=oITf$+CwdwjK9Z|&y0-jEH*He%8 z)qBGaI-8fFUuN17Jr0SyZ`T$z2>P9#$QE(lEDr_2P~{d!l?P;vWnILJYU(01;@BAL z?YsFB-zqS_V)z|IZ%FjDI&B}R($^KuDYUTAP(mY!+i|{N9skUiD)`phJ~kzn-|jsD zw;+e6%VHV&3YEj?;4Nb{reR$e0Gl*OD9L!iZBXripcUG8EuDu#Bc9Kx^0D;SB_S0W3~9eirtuMosa4G_0svywWtbI?{m6#) z-j6*1`xGE%7p}vr^=0tLr~ay!LB<#xt0IICx^E{PJ-n!iQDUcMlLGBG+tJn=)o?m& zmFR#N5p}}pR1B1yCfZQwKQm`XSp;3L1`3##xygu1)mjK+~W*J z?ZDrd6J{=hC<1=RgqdX7jLqmMX`1x+8y+#%7>2gl_S0U79&JUwzODBKB(0}ZPY)AD zCK$}S)Ungu%Q7fw91A7mf_`1`P9C+w?U#J}vw$~+Y=Z4V4Z}hMhRXaKl89%{~<>^Y_1NS?kynZ90IWz>Z&B5{)Y|-=kpRGu^Fjf zjV1|DH-IKiw0NmB=Z#_265s?GlT^8k?Kur$ejea+j*UR*6RtLs`o|hT@D3B;&CZuv+jBg} z-cso0^Vm-SWHFff588S$9i7&?Wsk2afJ3aHRm4vJ7Z{-jAx4^B@oV{3V)^@UkwVH2 zoKT;KEXoeyHxFkO*Klr>7&td_bb%M3zwq4+@%qv`N(RA%eh3T>g!E(Q=DzpY3?oE?E0zDFHTMTkNU=q&YD?;v_}Gw=ox8ppC% z$LU@NNZ+cM`5=x%>8pyfZUOeas*ScVlsT~50!+SCqbR59d@0fdF24iBp6>wO-eAf{ z03NIyL=n#{gMTo5)_d~@*%6^dGr)0Q|E2H|aPSMd@D@ju{L5ELZiUV>*-PD?u8AZB z%XGga{T4~U=~T$~kbtO1`Q5QW!3z583N|V~qWxjuau~usF4p7D7V2`>&fe!4D=5I8 zjUISZK0eIu8WsUK5qHmw&k7^V>Cj97x<*B;l~_NK0R|CVmrS*hx4cjI{Qf|%oQZ&@ z<^bOu)OHqdJ7%(l;XOV4999ToHPL=#J(LA-w=^ggG$V*yE2|VCNZUql%ve=WVF>oE z;e{FfDlb8zE*u28THO-+I>E42bP;u2&W=Ad`hO+@)_lp7TkJ3<1iBUh(j$PJz8TU# z&*!Qb#BBhBH4`*`-%2QIFxPQRJxr8Qlw;EoE^%*|{mn64-+%dOW5!>n1$-^3`U%a< z_}C#hI%I!BL-3K8C4(`zzCJffA@9<0tjx5 zDm#q$f|epVvQcrkhOthA_wjD)EQx;)kwir1;Jb^*1t2y6W13?V#@Nk(wm? znEbP0?ae*p8BZS?~Q?gnli7r9O8StBe8nVTf z=}B`HbbVb~2PnhD3R*;HXn?;-Z+t7k>o7)c0&-I|J{?p7>?sNA)Qkh(mV8RB#+%Sj z9U#!8BTbhUP{LZ@*x2~)rSP|~d`)$)Rs0jscMUDG1smQ%?GV7?G`1~0vkMoMJPuz~ED?u!MdGFv0$nmx3jkF@=xn8 zB%_1wNb$Mpj0g=CBLcFXl}+DN0TfUM;-MUHI^Fc=)HfLv{G=o}?7K$H*X3+ZFSOZW zm#<140eYh#zpKDBVpK=G4#pS*nkbXInHywvf6LU!;cq(O{%jO&*N_(#ePlWrC3HLyg3^bG{0q86vD{F+NqZ$^}1CK~qj_W@mLIJXqfBn(c-D+pPz8_>O#K@Vp z9!g4~X+qEBmbf9#epD<^dq<=@V5!pH*5Dk$^vZ@dMw~uSHU%63h!sO2%8*>Si9>8a zDa7MO5Kwn9MT(w{tuNI3=ANL4X80l7{NrXu_m@SwMd7=*(xAh4tsonM4)%J#3tx%Y zTuOc(PENxD9+fh;C;zNsj?k*-k=5sF5N05d+^09Mdj)TNGk0D4tK)5s00bMkGmA>( zVQ@sE(zhi466Og(5~H4qx)td9XmHwZ*5>~A>h1xrzs$V)c0P%NPmjDwk39kPbcI!8 z#qqdZxNW6$4o4;Jscq$O<=O4=wbUwmcD=U5Os^rnZ`!XUEWZv=8ZSb=DFA8FWfpDk zvwWt^_oa(Hz#hLqrbHu(eXcJyGRh)Iwc}wNf!Ol%L%pBYU%z0ipF(LJ*}fu6*4xhS zf4A#i;aKXlkq38N3Hja#`|acliLQy2?)Grj))Ba+cBe~!`3tD!Q0fZFGEqWvAU^GKB1% zME0p`S$&73gL8)E7o=}J-moRqby#azd&XeqXAhFd98=`VrRH`9n3<2G#e0Th_J>=p z=UeB>g=5}QCt-zj)5`>RgG@#<5O#7Cm?|B9Kerz!cN&hgp|p z7&s@xZ_-PWhr39s3EOp>X!6~}(Wl0jm5{jRcN3Ni@er5Sri;>OpcWFHnif+A*n{z9^JFn+5uNP`SIUx z;g>P}wv@l^m^7B;$#>D7rPL(NVQB$C(!XJ`s(>aLL~*cZs-E;fWEqCGzS)+!a?@2$ zVU{O){qx1%za*Oik&>qCb*aDRFu7zm@^?&59P=Y$DzcF7TB`$iIU6q}e9bt2FtZHO$0A!JPt_00PDB=>d1 z3!d`guuOEd&MZafv|gHexT2l>>(=)SE2>BSWIBpg4^p3t!tygIDqLmXEG031hF*ld zBfVD=_-U9tEqCpp$xRT!@g}0}7rh-3h^ZC=rQ!_Ej`=HAnQWmDBKUp;65E^2B|%q8 zgz50q^R5OW_mk~4Jeq}KJ$I%rRn?~PGuQ;=}7C}&2^#dyVlr>YgJDN z)wpdNKl2{x4#(u594#_SA}(23h0aL1m>IOM32!5Y)_j?`c>5BXr1hRWl7})<+`IwR z%6q0tzGQw1dVDXRJQju0OnL2cgG+07odY9~oHXpKawL`s(S{f(k{`qB$|*W5q_$MR z0iE|k&&zp_xK=qbP`?;ZfELnVsH4XlHDxxa(z~&ep*XGQCp2aJh%Cpai#DH=KDE%A z5m%_h2*?F>{iIV@0KObG-&RKT?V;G2T*+NqQ_ssmVf{3djP3Q9^@du3h}K#@i#4SQ zOBDoWGnUI-u%kSmlTn?}8mS^!)rEZ@5I%dW!(e^;CDKfqN|8hT9y8%NwXStNmCI;FV*z7XT09|8hz5ZNJk_VXA(=3-}9au(g|HU!7O=pcyV3G zwj{ynKFPMzsy0fw!W>c8mZ35mfI3WZ(X7H6vXsg8gYq|AEF~t;J$}O99+0t68KY3P z?qo++QY9hAk2H)D^tL27fhH3Ia0iu+WVj|M-BEt%9%-f0Y@Y8cWmunx{41ggGvZ{O zaKf|8AGjiD8^;qxeu6C!kI+#fGNq8Z}`ARU9RLoR|r;;+?0uqqXeQ(Fu{iA)$fLUf;fAO4hR?SVSPMbic*;Of07}YnjmZW zCK`ZFU*4;Ho>`L#{Xa}SxrR_q!#81+qhU+`qMQ~8SKl3{BmU!olfM<34V5U5H0wnr zqx$ELnb(X@d}B+3V%(oiwem|Mr#IK&KlYyg+5^*{#z*|D`Se zkK55(-718?*C8u0{yLntF1*k=iW1Ta$LY&e$193D^}!E+Rfnl2N09d_y*GQpWKxad zvpRB)KU?=_FZCkhdnX>k?{qRwlyS3BS5!zA+Y=oSBU=TQ+EWu&QZ7cjmJFRADsa=E zOl|I|SkQY$yChtCDxKh>Mwz^)2no8r+(jkP$x5@tA@gYip8J-u*3V1^!lx1ZQfd$E z(tL2{&R^EWcNv(0$a$Z2*gP{rgpXE~_QFMpJI?!ub*6?#<#lwKO<}ppbqq`}+A?$kD!emmjWxZNrB!vl)K36S&=+aYha8-?du>0b@Sm=Ipau;%M=#VQa2WX9o$d43 zL;L3Y$I`V9SzR(1MlYFGj@}gnA`O$+cnTKpyC4a?no^S42i)ep`O%1!IWoUo&V}u` zMqJt$Cb^!G;~$v?6boR95f642qn<5s8BkWVnf&ng&c!lc$1pEYB%*KLuTL}O@2Itc zr6YZSDYMQC7a^Cum3%a&8C1BB*3N22gzo7L>+Z54g+FD)jao&ji#Q$UJ($>69ZHQX zIs87n{f`-EGUr%8UrZ4_fFn6|*h7GvyDzxAQ^3|AU11Tq{2Ib#jIDpjhQA{?zHR!R z8`z3r(n_phFMRMnOHm&Jf5p#U)#xzrn~Fc zID-Ps+$XP?dBQ)sMgM7o;DvuOm)LkPZz+z?IkD~9_tgwxN7dIMiP3OLLaib{uqUvO zBe_YF`;dt`ONNJlQP&jVZAUDOloqnmu9HdnYeYDqr^c3Vv^}$Lyei4mr%r+`K&(3B zyqe9Lg!R}Wc>>L_GFPnH*1Df2(Mr|CYC)cJcBsk})3HZKi!T*%#t#K4Ebq+rM;glU zFo<^t!qvclsvbnxdWe@BTR|MT89eXBM5rCUpzPHngu zue-b)+ z1cu&m&$PRokwFB((t6SR!$ul}7;$Zhq5=}PM^~_(Ni`R$iX(;kZIb4?CV$6X-yST2 zt<*c5n%LH$*%Lwh%S1`XD>N*LBR@K}A)2dz!d(^-nIMLLjPJ=?7CZlB%_G{_V?gme zsvM4|x!-x5J{u+7bWG@plSlOUOWJ&j%tC)e5sTB{h1_0mSUvxy{NcS`WwtX~V$LcY z_!8MwmG8YSI6=LFxNC_LVQGnzYRL=95cB1av%uM^AASq@(zt@D6`7a#Sx?O5nXH*6 zt5b94BJ$EPrt;FUH2}f{C>Z3q*$qH5l3h-G))@E zO+Lv@G;Mb!{>46`DOrVFR!h!|p;0HVvp&!$!86x1p-bebzDC2D=(YobV;si# z5$jziz0Ex#?qEGFiB!#Rvj>gb9j5G|6V_w^#Aer@P$3*W|Gk-(iyY+dSQU#SIT;aj zN5IWmtiO+CcC@O)m}F6F*7Uwy2?&H{lPCgn*79D}SmyudoYWg5?D0YNb+~dIfI&y2 z+31Sl_NrUMMjm^hdla268(vl^4YAhL(3`R^KPRlz4 zkgvnsD?7cfW6<}AW~Tg@RzSf14XjO)OjTAsU{HtIf>MVhG?`UOr{YdLj&xtyZnXh$ zcE$JTEP45!50SD>+IMW!TO@CO_o#ax1)6OF;nj+){{&q|3iRR|O1V!oI|M47Ap6cJ zoAJ2H+$$f@3v)l8WMH$8R+;%R-2SL`|4_KG)#jVRm2jY3+>82{z5-KmRddW z2VjZMe8IY7;tF|}ZoIj2*1K}nuhQrh!m<+?YLk#$`C0XIsTpvks>GkQf3b}Ls_~}2 zb2TC!K;8X=q%Xrp0%Es-P5f5B!X&PlOFsl1!<^W+Os#b_9Z@7t{iT`#YU&vonE)C{ zk~(PmUHxS6ot*P3?YoP61nsMwyDzDmL+T_0$!1<Zyc|#G=1uOTNke%`AzFjG==2 zjhayOTaQ?%VSy$ZZ5u;S5afq%$~NuEk)qS?DCY2O>FzCRAo*yNgMrH{e}22=4=4mY?ijj9{D<29j@t`D~*R9{s!D8E5?L=#9ck$?Y&X zE&oPf{BxX5FCU7oi>Pm*>VL%RsBoml>sUAO_(hBruPG1e+W7t!cm$C>0yr9!sC_(R zI(_!0aYI{~G;2!juv>5Vye;6URuYGM7jP>aG;h?Z(ak&ad_(0-p= zPjPADLo^a4F%@1O@=oZ$>#YBP3t*L`#T*3UO;}aR$r?t6+WwEsdh8$y1q36ot6WL! zYdD6^e=!VE5|3qGw`v(mmc&xtt&+hLaQ|D^JC_bonQdxLi?86%yqr?tn}1cQv5(2s z9|6nEW2N0@PC^UcB+_LU{S&Xyn0gw`zCh{*8azU&P-j);II}o?mV*Bn1<%r9-!0bD z?YN6%{6yQtMp#60*Ldp?v}X=)hwU(IdBoKNSRX>6fE5XtXTK>VyUV(LDZw3q3#{Tw zaG8T4e?!2`BNSi%IiKUUZg$#^HZkl~@4Ao-Z9F_d2&NeMTGabBjxPJb|5W$}hf zUm`C&aRqspkX9&pAk?yRu`vJtl{(Ux+I+&k4m2#~;N33=qV^CfAQ)_hO7p@SXgdm9 z{^|yN4Dqv5O|k39YSYZtTDMqTYoG@+{d14~$KBrV20F)^aIXZjI(`FRNrx(m!S$rW z^&B9qMx0u1(q%Urhj^^th3-Y-M*Nc_3YRm3yo{(joC{o#FpQedvRXe%DZ|4{+Jmr@ zxeB^d=yj9=E`t9y7vZU}R9xfXk(@%p-^}KsQX#G~%wfhkFho>?v^1if+d- z0Fp~17c2?R>)4S3o0jM_m5jsgnHvvx5GWCYClhHLMQu4r=3hcX-!$hzN%h=#RCJk$ z&bT=}SRyAhO7SmzDLhCe!KTw}db9gg zQ=Y&tbVA8JcoTmt3tBsp(&75Q$|ZblI{K{N5$DpOX!SF#V_9ZGf#vLTc<4YooJ=(# zZ3x2yRFxw`iAO=O0!Cnp3WWq&{@b$OO-CU84hDcuE^l2S6<#gbUCHfB7B0oV7HcG= z^4NSDz@Beg3W2{>Y>7zeD5o&%NGm(B%5U$&f9~iRz^N?+CQA3wmI5E6V$)^wd#y1(3ICH}oRHRp;qi9E>NXc|f@MO6r6L9ouV|i4PvfX+$_+^8 z-H$TDdO(iHfTT!<_Yp?TPJ+KO3A6g-m&1Q|u$E$jJuI4v^5Q0!aNSgL{E|it!<&u_-e?6&+Vv0#x2RExSp%}yW$ z$A#aYbjs?e;G(Sio^u4MiArOFL($l2HARV3$8}U~_$C!-a>cU7)vMmdY&JEszhWR0 zCnAWM<-20}R=2Ziny~D_F3``DaIY^Cd{4q)KH9?xK;EHx|0AKi&RCcBHS1kpqXQ@M z-hQds{XXjY<~`9l#oB(+WCI#uDjVK&(0P7gJp{%?<=1%0v3hvBFZ9vryO2PEA%z?` zU)q5U>SQjMe;*Ri`*-E->FXHF&V|<#M8ryeylk}CHv$UfD4!yaOYJF;3*^8VMlH;T zrDl!als0$MzWqGY4vYM;c56p7no_l@4UuzyW3@o3V0!yd^QOfb!zumhdbUcpt~ya} z^i#iErIuW$jreYv(T74f1PSbYxQ{xMJGE^{i2)7vC*=MXu<5Ux*(!1aNKTTk0Btkw z977at2sLsP96qcM4o}r73llZkS>qZ+>EV^8q(gze(x?QRzPg1c=|K!WS@I7&b-#1Q z0NTcs;~_@<*wUxv?)A3OnoWR#zrB=}>l*7AM=|>T+;cXgKxSsYW7nZ=YOZ_dB>3hZ zf*9?`zn|fuqQ|}gKQxO7JsDY3^{=7M3fHPrK%fzB-Ik7Ca7{#vhPl~_%X$hy>`PXkG;}b z%LPA#2?`kUby#&bSkM{Sw>5bFwiOBzv4u)$Q-yXIKZ3id`P6hJ!BI7*Rn5bW`?k(y*qAo@9FIJGae-kT`LgnvYV^Di`rdOu}=WKUv<6kuy@S z7fOtcfEDql;umnbqc4JuTKOGB4yyCzyh7EYrG!~?Th0w8g5dw8Or4^ zScYl6r++oqu}1ije~n~@eqhm=aq+XcLekYveDepT5aO}`Q#P*?%+Xvss_-JdY+fxj z##TWX`))udO0O_m?Cy>boiW`dgm>nXggTP&QDWt<0}*0L;Wjog6n^=QcbX2>+cJ~3 zziE*IuXbp_n#fMY6?U&G@d$;AzXKY7A9XJuI?kQji^K?YZ@(|7ejh71JSKcQ8}D$B zqWcv5S)B1|)eV$vrExibD9>x}?4WQDS;FT8aNxaqb!sOF@>U*6EoJlyUEg0^SWUTY zw@w0g$c08@w$`tVgHLUFwxQzFX}z5iC#5WF7Yf1B9ne5v&~0620R$y|w?e?x#Pq0Q2AXuy_*;27cm( zU9S%*a`7BoiG#9`yeSv+VQB<~TC& zvo_yNrBm>qw+0Pjx;O{lVoO}6v|d^`(V}(VZ5?&Je`G@XQ1KZ_h~`y4AK?RuY077& zz;&_lu1&CVyT}JFe-jB#T^kxyFX~@Gzo|rw>G*tr??hGb-1Tz=M;Zke(wzE|4C3DS zhqOGJtR}e|eNnq|@)=ziknDym2`YM1q&h(?iKh zOn+JU^$>&JF7`R)1#G>$lQ9}z2LCG#gLqs6(|?g9)1~pH7b>W()Cj^4x1vKUdtpTD zHAxM7yramQtU!H^1yub1>!k%uK4%j(=3V%DSoCu9xR;}io(Zr@h zPQB4H`Nq#DIhMA=4PuYjd!j2inQQgF^BDB3wc+}SUvQ_ll56bs9L9HDbGq>Iiq7vf zE)tC{@c#HB6O9=4IXup{v04$j{KO7D)>S`YG?yRL!i|D$GiH;x`Mx_p{+PQ@N*$4J zxqV@XmKkx=^k=zIZ4~CEbde-iT`SQ3`?uV793Llnp1k@A*|27g)5I1H=aKY~f}295 zx1AsHNo+pnZeLQF1>*Wk6L-R{qF}<|@mjHd1(EFNNSK(>39SSTi@T3~VXz_= z;|B>oUw#C`to)RrKkX(Yby{rqgX_fECXGyc zwbD#sDv$}y>c2j(KeTHW_)d+ymJ=zef5Y;N*y;pfy7u`IXO5m&or%y=aj{eMBleVJ zVottUqNP-4_ID}t)Q0}h(vN~#5A5p16QJ5&K6r;lYGV92*1$XoI?Z-{rV2qkPPUR$ z(**xA_-kXZA+wy0jacO5##Q-UBs|Iab@My%E{*6v7}PNZX2xN&^kr4~?~?xrj_&>X zr#Yp_c;?;CeH3Zaa&pf!u}n%YWS>D&Foz{%t=(JuyIn^5M|ZrD>hpsYsTAi^pO>qw zNtgu@rCu-z`6u@q7K{pa67dPcPn5AL;HsHF%RCvYeVWtewYEuY6UwKnAo#uru0NLl z(R)<<6aucS;yPvZ{pAXP&WSjamz65a;=W&T8 z<-$DA*<5lb;_=)5wk^Ws+I*3s@t%gNmdAdxuZ3lk{e#fOBDTVR(hz&g8qz}BR?m7H zzKd>W>=3CO43;&F1|>U>-{Pn@$+rVckuqx8>L+1`Dy|gfA`A#tbO*%2**-=Co%>`V zJ+zcn?EHj_Xb#$J8*;@U#w-VP`B+J{NJwe%B23M!88sJ4CqV~x5y9+*#B;|UF&=y{ zAP5*O`tez;NTP<5|7IYC9vDq;ipgRU4@#yDCQ@ggBH#Q#%`o4!EZqFW`Afbr?^c}j zjM}srFAXU+%+ln9|K?=1wn!j+^NuG~RDclSCaBFX7!ymq3MmWxSsO2$T|y;G*%4Pr zCO{1pRmc_hhZ<8@z>J2|^n|bC6vH;-ajWAg&Zv0$nDAK;)IVjr&2;C$kXbx{r$CS_ zB7c$g?B;@v10Yum+ORs(Z-Ci37noCGO7U<$5r6mLlkveVs1pAf`}|JP06O`AZ%t`5Aw{hTJYQhMs%{k7>Ke6E|mKzlkKG z@cnoddAa{@`i;Fv0a~1q0OAP6xe-h7SHCit2U-aux|Dklji)JPkELsqy(Ha%Ag6^O zsfdt_KogzfApRw_WX{xA9#WMkzjT-f;nbJ}N4u zx_-;}CPhiQKgiQ;bG+-aKO9|o9zLbpMoln(O$(QtW*o24o%1I{@0u97lk?&F&PAG6 z7B>-^j0$0!!!V?Svyz++D&=!X=1hO(CRL~gn6u5{8&+z3|L2fC5MH3ni8**6jwlrB zko>8p(&*^g|BbOdsfjp3W3JZ{Oz^z2NitsYfqaFFYVb6lT{36pD;KGXM7eIQpBD_? zFhR!0|Id1=*M#o+7Dvi`7_-sgz!;>hN0fti{YvwllbqK-WZM{v{|#2CWmvByI0N3P zdkQp}_(Y>JvP;s1@NAri#8~SJn%5(=DZ>oEUgdVsI1YhHUk^Jw;&w4Gb$5K&LFB!Gn2Q25W89R#iHct>5<~dcM(YSvuBAR{x5(a zsR1NW5%PLTr&GVjZDZ3iRNn)n{37e}^S(x~vX$W5uSAyr!Uhkff|i}dJM%_+ZZy2s zq~rwyO#5fPVA{-7b^^(ByeDPGpOiM1vx3txglwlA|2Gt78S~v( z>ANi4C_KQwM1eIG7Kt*{0MgWU6mMEcnqQTDk+3EFA6!_rYi-SX#8nMXW$SNN$&&x! z>o!%L4C=vghS!`Fg?2FFCWUw%o8!;@_M^gwc(~POK6IW%o*ZiiBN9dSv7Vqjw==Tm zX10Q~QYTS>^bZj^Ry=UucC-64TpCt8t^O`56rQiqxROfk|PN2^m z0;J4SlW9F0SE=)>r260^qW{Li=Op2!uYImZdLsP~gbsr7S}Ne$8NLCrjRf73x=e5o zt;oC2p#r33L}Xa;IfG_D@yu8%TWgP`TA0D)SaV?!C_^&lbDtoL@9~y&pb4RuL7_Pt zUX>Ffjcj^yB`gC!kL{WkUW##@K)M`!q|8hU2G`1@r(jzLwr0HI|Bd~(&Kker>pWY9 zU#apxY;kgvFny~*WSKa<(BslPBD~9>kQ|_Q(S(Q~okGGae4QymkL?WEj4RI^L8cra zQs&#-pvh#deMwYfZ?bt)YytQGnl1ADd&=P*CA%9UcRaBi(6wBhz?i!S^s$691I(U#vi=z!whz(kdcSthiM(EAI2JZ<*@q{fk0xTY$TfD92`! zh_Kv{-{~?YR+X(0!(dwi(#YUr2}wjVWm2V7wzp-5`b&SGFmb>GnD0G+?zEty`ASM3OzQDr=RkADr% z(eJsL&M+JG1w{s*_DUd{iF)y~K7V_%tEt%>K3vMkL%q$5DS^)x`)015)*K>jV^5B? zEEkS4aNdQXw@5T764cP7Tt8VeSB^`FfNv}S0QS@^%<3R)Lz@s}p9l0(kfEUbrL z?~8|oqb!FJV=-gN5Z6hR$*u7%ewW#^?7iAqbI#{6!JH)9{hxp>Wp4Wb=k9eq?ym1} zgb$~YGJX#R?{Y+M5hMeKbh+z>u!Uls$_S=x?)z-|3PKQbfVZ@gh_VW*Cr}O!1~Vm= z{JE~UpPgRI0TY?tz#L%SJM?Gsd)S`rYf@RRR>C%ejWWS-lobrP7zG&tm!x!Ad4buV z`?XaznDZEL6{}%HSZ@(`@g+E;3S80>^@TcV6+Jg-IxW{*Jtq7vSYJ~%DL8<0^YN#2 z{D>NCuyg!xHzg25r2jYq zhE^&cZ%i{^Pw7NwaNq=at=v8jdBGlM{w%rGx~*x<{=L%Pzs_b}e0hw>)_~I0tyy%J zHRcN7c8g3~8fAU*$Igr>Po{&pPU!^?(z*_FB0(FhW5zZ`-+C1;jbB9Fe;D*hIA))d z!cI6o^8bJ=IQ=q!!1yS^$8Hdfs-Gfd^y#_3ojp#WuM3ur$-d-|U>;mr_SPcamXVJX z{1Z+0<4SosI(yne)uyexNnE2XYI3}f&{7oEUXE#X#f0JT{pwj!BawSq2kRwGa~U)^ zBSNygkZ_tNf#9|>qy_nFye-14lfLCOn|>;p2f`uusn(K`0R&G{~#^LZTJbV5-%@}x-8HlJf}%OeJ4gmP4lW+6)%lli+Y>bBAG0f#*V~#oR@pec@8i# zl8WC@p=qfPPTRJsiVjD(yBpl`1qxyNIz~Ek05LYW@5d@^bVsRwnXh8|1v^V+^wkB2 zzINrEClUBACw{ad`czfuM?YWSdd;%V;E{3c`AIs-190qgAATWFYJ<3krgU z3O9o{W!z5xyPmv-wy2AZxj~sCGD8|&d!-u^1iLL~6wk_E>45GmF;aw>-(7V#Jd}oe zg9{{_bdk}pWyAz$x0-@wuD;ih;#^`hO^LyHTidw`Wc}6%85g~KI@l^A(SR9gH#fUY z!_(j9U~GGDh2J2Eg2pT8SAf@R4Yr7_**O4f4d3EXq_D9^=ii%%G{vkW z)r0+vN|3@_F7I`*MtMSwJ{YTRos3hKcok^hw%ix-+v_S;1(WNFr|q9wihf1WX2Y8| z`xu&KvBuQqji!S~o>$!A4D2J{UUm+Xto$Tg1d$~BU~0C0>;T>9bkL)wF~k#GU9d6*cp3 z$LGG8&#l#Ty~Es>o^%}Co^;$POhM74PiV$L3x^J}@7^z)QlZ+|)%lBrTx)1f`hIXh zoga_Ej%+mTa*1mI>A0Y1QYRE4vxY+p?ii%o>;Iy=ZkN;>T-8&2{>u15c_w3!jK_Iw z&Ki+zs%ll1LnVZ2kq;zU%TD`)Lmf>1nf*ik#)}9;kfDVA~>l?jNllAHD##LJ8>f9!3q=^To7FiwYPzd3Sbvo1w;h z-g+nD);U3HQ$z2Qo_w(-M%CW}e@+7GY>@XlqW<0%Qz19{z~7u2!YAWs;q2j6e@Vuxufp{EIDr^w{4(Gt>i z*6*}}OLmGtkmP&Tuhx-rJ;Di%!7AJCK)w|6Hhm;hRZ;;omM(q~nmm6*I)Jv~=SxIh~yxotcz;F72PluD* zKFQ53S-O+T31lU4IZn#>3-GVoF%f}-(XP$_T13R)^)4g5H2xM8pdZK8( z$@tg*bTtO0{L4`9cw6(M&+9D6Q*grV$jbAgL3wxaHO4a;>KOD9+3@`>pF{19nP5XE z+l`)FOl@~DZ$!Wx2Tx-=Kz?_1r*yWBmFTe~pP2kiOK4iVT*>-FMt^(FiQTI8G1Pg2 zyuzCW*~aKN+UBE+@lo&YIY+N|O8w%C)=MRK0Fb*_^vPLLwv$Rr=t_Hvu%|ztFjZLz z;_fa|w7k?Za|3l&FeUkp$;eBWHyQeZZ^Kr2{5v_BYM8)7hjvbM|35K<7ybjUPzFl+ zSPO`?etEX_Xuq>={qZw`=x4a+YX8?524&fQ73^9xwozXYBbr0-ODs(3HTy&LWd=XI zt(=8uB_5@_{y5Omj<%P|1**5A*v2G#P- zcx@#5og$tov>VdmdoXe1$ezO6aFfdFi>p;=vMwu8?T7sxY*A`f+xF#MDnY8Cco=QD zD9h@=`HiNWs0}9dR%NHXYYX11DN&lWgLdB&J!HP-Lm{;K_XV8*T@K-^-`HiBxQ89Yo_9)ntpap^yRE(9LD#MJ#aX zWhsv=nG1lmKN8{O2lJ?1-b$qR|I^r4hD8;1|DKtFA!HaD1f--vK)M+kk&td2q)U)) z21HUC>23k(k{m#3kQPBoLQ=Zx^8VlZJonyj_v6{m+Gpjn_C9Ox^*cKb=?}~!dCS7n zQ%TY=HJT!M*~6VnK)!pVdIS6S%jQ|C93bdc7b&#qNt#CU-s5i_Qq~ z9tsG3BjHojtDx97Rj#-j#I{gYhWCYf64E-EX?tf(EI(IgFnI@LmX&9e$n zQ!5Jh`wZGu_wx{^;C{Q?I)~w-ox2y;#;iBOS2K3|*JB+dxF7ZpaKFq*qOz=dY@Y}T z{eoywGWORt4rw63rlM-)>o(C6X!rV*r4eFnsn014f64xxoy6-VB&8Z zLd$}4F_Uk_42fsq;A7Q$VFeo*IV*%k35LPUSxD7p9F8h+Kpfmgl_gg_g=H4|N0!t{ zm1BtMvFRU+DhvbswhdOgv@sPRti^XTWMeb&F0ATm{M_f3_2R>rcq_D4FP}3*11*rD z08-@m#No!qzPjo!qxDc{=HY)`z2Yr)vFFB5IA;!5Icw2R-fJ7WWQ7N$INbam^BeCJ zRFieZFkjlbc(3)+@9)QoPjo}QEfPx}5&<8$7A{2cL_9JdNRA)%Mg%n94_vr!FjE@Q z)lPh`by#JkLW0E?Mgzghh~XZv_#I4%Ns>Q$ z!%SEdCDm1k{vjpF-;_s7D;P*CN+a4h3rYNvVDU@8z97%+UW{k8Chs{VF={77@@e(B zv&>##v0@6sqTu0e9u*XrYlluKg;g0>>P(tg0vIfSbS}nYx4>LMZrAHq$R@Y1C)IzE z25vTQU*^HJ?KE2j;6(|cjL#f9S{L#{)x^lE2@^^7j zYq){age}bJUr4S0nN_QeWXJwulfJI|x&Qfyj@6l2nnMPwvc}Ka6U)ccZUxM!c{`^W zF>5NOpJ=_*{3QC9KWp92iYBCRu`P{Ay~o?M1Y_}8m1{s2RVg2kpZg1c-a+KYOyFA+1bRm1H zo^2Uf%VEsE_Lb|D-~?aS0$5*4+vk)2MVigNc}ufR(~sX9dEz&49!+XF*=BdDfgnXc zi6Pw*>2NYutJ2U)VrWC2wgvvr;0~+-s_OweWL+*94nD#|{!KG2tTEGhX+yDNtm6O0 zC71kiI<^_P;lhwJ7%wP7LzyPsauyFLM>-BtHg60*RnhS1ur4n%wI)ll2B@|uXQ*gg zWIf}=O;axl%%qyJqtQHXe#8x~ah}qDpC{RVtujG^Cv+V*LSm9^F7-X`ZT4?gHeJTc z-6xF5wqlY%Fe1 zN!n3(tzxJj?as+nL9aDH+8$w|0V070=euD)Y7!8-m9IKmiK&_pYl`ViN7UUiMFa)m z)K3URSFbYPhKdVTD34jtRmWOEg3!EQA)xy!U^J11S3>S@HXc&-FTV!X@SG_bgPUs1 zBuSDv)y%M#g(0~NTXnv;d+ql0&&!T?-fb^bH3U~R&>Z_IyW>!cl^kZXxeskVibb~h z8pJHZioprbXn4!Rs$~>cs^2}6txuKK!V`G-Df~ae}A9 z&X(a(k;c;VE(y#rD5g^zptF4~on*4I?fWO8Lt72xK%0LsduotxaR(M<%OEBY?K5w$ zc|f^&p5NvD8J5YR^7f$zjkdo5iyKC+CMC(nFK2vLU{J;~ntILBzPA!^_+t z^0=ZkR!PD5!wRZvw64p>%BfaAwj6ptzFogc<&k?Ka@I8_B3GdAWa{Fg+k+@ja;J`qIHhP6(EOy41i zo#4Sc&32P6220Tou66vg&-TI!vBn5}L{$D!z+zpV>Jt}!l^6Ls zHLWEI*Cey0ojKWG25J@6jvj4@6q6L^nN|7VBv|^=S{SWvQx*N5kXGX$fzx#=!!>|W zz%z&l)CICl!WyH3n?^lTCI0TW_=0Nr2(PIG%zDIn&m^YlC-)AbLD6C`=Q+G6xAxdE zb{zX%G*3OT0M;KjJg9XFL2(+Ft(nk+UUaV+3QP5nZ#f>})OX~22YteD`5Zeqwl?{X zo`L+0#ROCuO7IN8m)o)ob4q3qT*f{DJSK6QrS0S+W5s#A^dOryw2b*(%*wNC<~(8P zlDzkx(Gg3#qL_~QKV(PZ(mgDJ?>#)*(L9*8uM#`EAIh0VEA1&|%4fmwH3IC3ak8~( z%3^v#^v;V>*_FcOFgi%Th;F#9Up4UpDi_OHGe9cynX+l&MR>RU34kBo;ZyuuwI1&= zV)+4$z+bK;Xq4x)hf@*QbF|;^cnjE<+1uN5u-n;}mrpnKeCBg*{5eB%pw&@w4C27C z_$#j5rMBjo$q**K7R-1Kzq zw}je|F&jX-?jktv; zkXa$0QOstApZ`8qU^*LA#9?g_KN!k`Lah*!XPyRG7uI{qb-fY6Y{megNVj*$%%{_= z#NsaaMf2x*X8^$_cHb+?idPK`fxICu@KHLd#ikp<<$Rf|Q{66}A0D9p+D|?gk$n8tCJ?L-2Md6B!0#IUPWJEl*G&jcz*{tqk z6UFOEV;#?gvH1Y)9Iom96HqqhPZTX05@^=Ka1&~tP26v7(eQUssn{zC?U7QER;Vx@iWKr3So-$0bN%BVkF|pe* zkwEt0nA;piC7<*or2)L0*X{c5PjxD;w&X3UFYC52LsLpDj<(W|)Qg%~9eU~R^mV4krYy*?qXw9NhrDWhTvsN#57sZUY}i(-UN2v0di5*nriEE=WFqO% z{E{OY=-q^7f1H>{fcokTMecOw4i0PANztg{C&a6;k%2*QlA~@v#@JM6r`p|{n~SK# zoc24jFX>>ifCeF^@ZbGa*|ncBR6xcIV$MOVA>bJ62A7-i`ju77AuiNhfuDFW_##ke z45M1+e4443=J|%-K2M(AsaC@yn?t*O$Bz@e;8_tClai!QA_K9Qsz&q^^*z8wsfM4i zUC{KZ!57;5Nb0_!?TR|6t2JaC5=)D3vBuj`i+pxdM=5=^m()I$b7E zT~vO{98K${kG(7t5`5=s;R(}pfok4vO+F!!@V`3JW*{oj2~Z+?u!zr1`S(@Jy34JZ zpMf`r*I#nbx4zeBdrm=t7Y7{ogN`Dicel5(w4I&~9)PUJNGByaG(fdl>M6L?_PV}T zL3PI>xJrYV-2h68=H(lA-Jbd!8L3s`+K9O^1GnC(DA#fTlKxPq@5t4LLZOJy^}z>zx{H5Cps(O$&QLvJr}=02@W)4Vbzbx zp4Z#X-EzLiMP8<+E^qM-Euq1B=m|I}sR9s)Z1a?=xL&m{oAyWA>s^OJHYdd8gdF2Q zAq7$@hec8Lpl=q}@jkd>K!_je^ugIr?(J^9e!1P>_%;38;RKOr-d;m&Bk^;uzbn8# z1Cj-{_`RuGliBegyaV;NIkR4qDYc)6dFngnkF|jz1$9i%GV3>QWa_I+6gODa!H?j% z78nQIcMT;JzQg>m3Y`p;5eYhmN8_Pk|AX$@7{7v?Q`HDS|D)*;^4Iopb%1#J!=d~a zTJDU0B{`O>0oRBBaymz_mz$dIntiADm9*Rd#o5A{6x>`rDx~oO%?JmCRks`85x$x| zmHvIK$OQQxG2~)PmoT_rF~0patPX;KI8BI3+$Y>o!YA^ z0P(oFCUvx{yS(wX4@|p5!WToR-CP92BWNyUn`mRuUgd>gw&1|G8r!ha}3~ zwtf{h)iO!@72^gJY*hivuduy*Sk?uBkPaQ8kU@ctHO zD-up;KO?Fj2V~UaGq-&anS?Z}i*>tbfH)x%`R`oLQUroT9yNP|D&E8n96tAu$2^ca z`^U^5!yB`Das2ceO*7FZE`Xyd>TO1kV^1tdXxqg3T=kw%*dk@nwe!9NAhG|0@rW3^3z!P52A;c@2Kp)IT=29>F-on|_JBL--F)0l#xg9IDKrVX%_Hu&&9`YL=-OjlGah`+9qX9#UVp(`}{&1cq0KXH>GPetv zHOLstq(>zZXToVf-~rp=p2G^$*uYb_wu^m@ ztwB`}Zup`G00o2J+}qQ?Xs4@S<@yUxij%;pM!@vz{L5X)MK!T4h~EQtG>Rj@_;y2! z=l?Q6q;aLn#UsR#&Qa9Z+!KrLqivJ6Zw_q~HzAg<96-BkuvdP5aLtbg8vzxcW0Lpu zA!hFP1>dCc#)qSj8_~wogMr0$q{AoempYrV6y{6YcWKJDiU{t`J=G(wtyH^jk04_w zy6g?rW^y!|ACds5uZQcMLXY>TuSS+}tIvO3vH0K$LnXm|D5~=}R-8vj|W7tsh8?yk%Ha zX!(y9)So8)^4HY@n9p~5hg~Ff?a`@!{BqOw!v;EkVPbAw_~F5u>7dy+JF~c*(+|czIIj2G&GI9v48< z@kp@j0egAw+5#+ukQjd-!H59LFk+rCE(Th>FHS;@$s^D5Q*!MEaolz+yaN~Sa1<(T z)jRX|>WB(mil2LoKjMS&u{+pXr%VAs2}CV7WdRS|I<~gRFS@o&e9!-7Ekk_IJHCtM z@i#zjM{e}Q=O!LNhbOwI{!>Ndh&8-#OfY#AXz1ujC@DN?EB0cn|82@}#&|{8a9fYn7 zgbtJEo)v{p1j_vL46W`56fbiI=Hakh%0lB6pgdbmNO2VT$o2x{=2B}MhDl&jM4 z4c#|3dQo6%=;?vI9>fa~K9`)W)&0A%NnNR3;^?;OG$SvLKu9)k43F1lHk|3?i| zW{=!3Ns9s}Cr{*bX#kH<;7tUUvk@)+@fS2s2i$O)RqxUAwt2Byz{PBhZQ&%yxGhj# z;@MEj`A}jqD$4F6qqQX1i}rCFdx-GdINdjo)GJ+xmsTbYc$T5~{RUM*28f!p?iGzU zY^;x15~ZUJ^N11S7sDF69!J*$qXtiuDz|4t6Jmi-d>U#B@nc>m%$pk?l3V{$S*7$p z3;oDZ;~UDT!`^2}9LGb)>+8_qV=FAZDL)%x^e^3hfHE2Iz#fNeN>?xWnM)O#T^jTO zy6TK>A{b*C3M%-mXuWU!wevJ j3|yuFvXAeEyW_rSAvi@Ut2 z&aTW;E+$BG@a2&_@&ybPYNkCh#7vn65yrr1X+h#3I|;A=f2IR$-F-0J0KA#j(X`?c zW_7#e#z|Ea%e7pr*#c}Tz_2lSVnMs}BSk_Alw%$V#~`U2E8x~#{G=ibSk(LS65{~3 zTHI4zGD*sU$raei(}z%Gl9mjQMqJ5YjkUk1PJo&Zv5RJ(Vcme6l!f6MUQ4j6wbSNeIs%@0EyT5YK=L(Azl zk?CPG>I%)W6j+#Dyoay9}fG0%3gaF<(t3dxhTnFzYd513F1yH;*WkGX909halX8iVb3vRQ*w!Rq!)U~`6%$f$; z{bLTo>%76E?Po^mO{vD!1I(s{N9V1NkUgc?Bg6bOAaShf9hGjvRzP%j%s3p_wyajm zbwC=V*}YDy$Qh=M4y?yEII_4=w!Gck z&JhyehgelrzPi1(a62L1(A0odC&x;_io7|6ef)m=1D{-vkIdeIn(IqVxwuS28XY=( z)f6>%{$$2BSm7aG(fnLuluPsrUL*fw<<2^_+GGIEA%9~HJV`uYFNTVRJxPB=hA7rW zvklr@73`q6NDoh?Itc}lx+&9Q(xk2{@MPQFhPd; zm9@B(+;R%>PhQj3u-vb5WHNX5$24dn^fdm+m1{NfE4$81WILFv=*lt$kq(w9e<ewUr>kG4)^t)QOD#RF*+H#T_4ch}Zm)4yFkHO(zj8DOH(6Aoc>!7 zfOI(hJmhyts`C`t_>eB+;`qhBySBIgh{zg-;pS2WWo*;*Rm6oNYnY$rUQu(hqCyIN zYz-*{1VU2-BEBL(ZcNqo+N@F+@t$T6iz??apaf!MoNk`&Dtwav>1*}F$0xt1lO^bb z8UM+-lh7;djjOZx6D*|sf2ih7q?s{W7p=G)N`XqP=Y8PqCiCiifJjpgQA^;#ik!WX zgFa{+iLHc>d9o<=Aiq2Y;}Yh_UYha${jdX8;A7_bsIP5uKlBl-q(lfBh#55&4t3^t zyo!=PO@#e-j=h<{{)cr};j(=4=w9u+DY#kGe~9y);stWJP_&37gzUeao(pwZwh^6z}Bm-S@wytW&gRB#C!+!J&?k@Gh|tJTNvS#)aH0c@WCQBq2eD`DY$&oND z>>YLB293eQz2L%b88qlTtPkmhAWlX?cE zP6^u3B{8TR6_afR1djIdGl@)0K3kuXW*q|0+euRUGV`xuDbeQ|lF^ZMJ2vzn_kIO>EeCFZwr zs9+!U#XjpP_~Td+(L7A;Da|P>K9=>YR=dN}|1_&q5|g-HS_1fw$o<=T^;_1GG%MXYjN)ie5_;n; z%~3ag%3Ei+vOy4|plPQ|LWin*sk5+JVEu5@1b+_Grp^BXNkc*S%WgNO!pix~LsZyH z!R~2RtNDVMYA^L!o!1Rw+u0TSg_~gd?2wN<2rS&1RaU1x;scF0hR>G)3+AAIaf zu;`@j_U%f6<`3HrEYYeJlqzm>gKMi7c2$$2zo}(ZTwX=j`dGR#*2(!90n4#G#m5=L zWh}0u!cw98V(UHpX|_HpTRKl9MMB&^`Wb=HQp_TS^Wswt0Q%m_z=mxD1C9>tpWFB$ v`2Y9cgo`;EYNG!HE%w#@969s<4qqghHiK<-@CYR6KLao1)#NH=kiq{8T#tY* literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree.assets/bst_remove_case1.png b/en/chapter_tree/binary_search_tree.assets/bst_remove_case1.png new file mode 100644 index 0000000000000000000000000000000000000000..c0e3f9e3968103bc4f19911853291a25dc96743b GIT binary patch literal 28514 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

    &7V-1Z!iiwCie!`HbHVbsd;WPNGr=RA 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step1.png b/en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..344f94c6339e53b86948cb9698f8792559389a98 GIT binary patch literal 16431 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step2.png b/en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step2.png new file mode 100644 index 0000000000000000000000000000000000000000..45b8bf15ad40e120f9e9da6e6cf16232575a6bcd GIT binary patch literal 26887 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 IZW{c50P!V#$^ZZW literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step3.png b/en/chapter_tree/binary_search_tree.assets/bst_remove_case3_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..282043197fa786a21c7a4dbcb62b947367e78cdc GIT binary patch literal 27593 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

    7G^&hJEs;N zsTt|Q)A-dO15w&L>BVOu^Xo`$INEX6<3^s@(YIn_2;j z7vwNi>Vu*$X`PECxCU>>Ncerc*YW4|N)6S%c6TVmiSXN#CC0*uIOF+f|0A|{HGnMqg5Y+I&p3xgyxPI9GgK^HP2Y)m#Wq zC=38+$4{`6ONO61s^+U>z!FzIt0RrJJWqzN+(#J8{Py>YagMm=JA zOFwqVG<-=s9_LSyglTw3kn^|!+DQj!%0!ZaEe`jtmb|sX&g}IxheJx29r$+UwmS^f z#KW6SHRa_kbY#Ej;7UM^dd*biY9>HAY8kS*n}{^9YE9Ax0)I~_H$DN>m_o-4V6%l& zKFlpajU}!*n=uXZ|Kl0R+a)Rrynm(* G@Bas}GDivk literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree.assets/bst_search_step1.png b/en/chapter_tree/binary_search_tree.assets/bst_search_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..ef9257130b11abf54370983302c169980e4308f1 GIT binary patch literal 14103 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 G{{H~SmT2|> literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree.assets/bst_search_step3.png b/en/chapter_tree/binary_search_tree.assets/bst_search_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..2822887ac225dce74114cdc5ae039e4bac51b878 GIT binary patch literal 15495 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 +HK^_O2IO=RMLkEjz$`>#4Mi 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_search_tree/index.html b/en/chapter_tree/binary_search_tree/index.html new file mode 100644 index 000000000..52ee009f0 --- /dev/null +++ b/en/chapter_tree/binary_search_tree/index.html @@ -0,0 +1,3980 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 7.4 Binary Search Tree - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

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

    7.4   Binary search tree

    +

    As shown in the Figure 7-16 , a "binary search tree" satisfies the following conditions.

    +
      +
    1. For the root node, the value of all nodes in the left subtree < the value of the root node < the value of all nodes in the right subtree.
      2. +
    2. The left and right subtrees of any node are also binary search trees, i.e., they satisfy condition 1. as well.
      3. +
    +

    Binary search tree

    +

    Figure 7-16   Binary search tree

    + +

    7.4.1   Operations on a binary search tree

    +

    We encapsulate the binary search tree as a class BinarySearchTree and declare a member variable root, pointing to the tree's root node.

    +

    1.   Searching for a node

    +

    Given a target node value num, one can search according to the properties of the binary search tree. As shown in the Figure 7-17 , we declare a node cur and start from the binary tree's root node root, looping to compare the size relationship between the node value cur.val and num.

    +
      +
    • If cur.val < num, it means the target node is in cur's right subtree, thus execute cur = cur.right.
      • +
    • If cur.val > num, it means the target node is in cur's left subtree, thus execute cur = cur.left.
      • +
    • If cur.val = num, it means the target node is found, exit the loop and return the node.
      • +
    +
    +
    +
    +

    Example of searching for a node in a binary search tree

    +
    +
    +

    bst_search_step2

    +
    +
    +

    bst_search_step3

    +
    +
    +

    bst_search_step4

    +
    +
    +
    +

    Figure 7-17   Example of searching for a node in a binary search tree

    + +

    The search operation in a binary search tree works on the same principle as the binary search algorithm, eliminating half of the possibilities in each round. The number of loops is at most the height of the binary tree. When the binary tree is balanced, it uses \(O(\log n)\) time. Example code is as follows:

    +
    +
    +
    +
    binary_search_tree.py
    def search(self, num: int) -> TreeNode | None:
+    """查找节点"""
+    cur = self._root
+    # 循环查找，越过叶节点后跳出
+    while cur is not None:
+        # 目标节点在 cur 的右子树中
+        if cur.val < num:
+            cur = cur.right
+        # 目标节点在 cur 的左子树中
+        elif cur.val > num:
+            cur = cur.left
+        # 找到目标节点，跳出循环
+        else:
+            break
+    return cur
+
    +
    +
    +
    binary_search_tree.cpp
    /* 查找节点 */
+TreeNode *search(int num) {
+    TreeNode *cur = root;
+    // 循环查找，越过叶节点后跳出
+    while (cur != nullptr) {
+        // 目标节点在 cur 的右子树中
+        if (cur->val < num)
+            cur = cur->right;
+        // 目标节点在 cur 的左子树中
+        else if (cur->val > num)
+            cur = cur->left;
+        // 找到目标节点，跳出循环
+        else
+            break;
+    }
+    // 返回目标节点
+    return cur;
+}
+
    +
    +
    +
    binary_search_tree.java
    /* 查找节点 */
+TreeNode search(int num) {
+    TreeNode cur = root;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 目标节点在 cur 的右子树中
+        if (cur.val < num)
+            cur = cur.right;
+        // 目标节点在 cur 的左子树中
+        else if (cur.val > num)
+            cur = cur.left;
+        // 找到目标节点，跳出循环
+        else
+            break;
+    }
+    // 返回目标节点
+    return cur;
+}
+
    +
    +
    +
    binary_search_tree.cs
    /* 查找节点 */
+TreeNode? Search(int num) {
+    TreeNode? cur = root;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 目标节点在 cur 的右子树中
+        if (cur.val < num) cur =
+            cur.right;
+        // 目标节点在 cur 的左子树中
+        else if (cur.val > num)
+            cur = cur.left;
+        // 找到目标节点，跳出循环
+        else
+            break;
+    }
+    // 返回目标节点
+    return cur;
+}
+
    +
    +
    +
    binary_search_tree.go
    /* 查找节点 */
+func (bst *binarySearchTree) search(num int) *TreeNode {
+    node := bst.root
+    // 循环查找，越过叶节点后跳出
+    for node != nil {
+        if node.Val.(int) < num {
+            // 目标节点在 cur 的右子树中
+            node = node.Right
+        } else if node.Val.(int) > num {
+            // 目标节点在 cur 的左子树中
+            node = node.Left
+        } else {
+            // 找到目标节点，跳出循环
+            break
+        }
+    }
+    // 返回目标节点
+    return node
+}
+
    +
    +
    +
    binary_search_tree.swift
    /* 查找节点 */
+func search(num: Int) -> TreeNode? {
+    var cur = root
+    // 循环查找，越过叶节点后跳出
+    while cur != nil {
+        // 目标节点在 cur 的右子树中
+        if cur!.val < num {
+            cur = cur?.right
+        }
+        // 目标节点在 cur 的左子树中
+        else if cur!.val > num {
+            cur = cur?.left
+        }
+        // 找到目标节点，跳出循环
+        else {
+            break
+        }
+    }
+    // 返回目标节点
+    return cur
+}
+
    +
    +
    +
    binary_search_tree.js
    /* 查找节点 */
+search(num) {
+    let cur = this.root;
+    // 循环查找，越过叶节点后跳出
+    while (cur !== null) {
+        // 目标节点在 cur 的右子树中
+        if (cur.val < num) cur = cur.right;
+        // 目标节点在 cur 的左子树中
+        else if (cur.val > num) cur = cur.left;
+        // 找到目标节点，跳出循环
+        else break;
+    }
+    // 返回目标节点
+    return cur;
+}
+
    +
    +
    +
    binary_search_tree.ts
    /* 查找节点 */
+search(num: number): TreeNode | null {
+    let cur = this.root;
+    // 循环查找，越过叶节点后跳出
+    while (cur !== null) {
+        // 目标节点在 cur 的右子树中
+        if (cur.val < num) cur = cur.right;
+        // 目标节点在 cur 的左子树中
+        else if (cur.val > num) cur = cur.left;
+        // 找到目标节点，跳出循环
+        else break;
+    }
+    // 返回目标节点
+    return cur;
+}
+
    +
    +
    +
    binary_search_tree.dart
    /* 查找节点 */
+TreeNode? search(int _num) {
+  TreeNode? cur = _root;
+  // 循环查找，越过叶节点后跳出
+  while (cur != null) {
+    // 目标节点在 cur 的右子树中
+    if (cur.val < _num)
+      cur = cur.right;
+    // 目标节点在 cur 的左子树中
+    else if (cur.val > _num)
+      cur = cur.left;
+    // 找到目标节点，跳出循环
+    else
+      break;
+  }
+  // 返回目标节点
+  return cur;
+}
+
    +
    +
    +
    binary_search_tree.rs
    /* 查找节点 */
+pub fn search(&self, num: i32) -> OptionTreeNodeRc {
+    let mut cur = self.root.clone();
+    // 循环查找，越过叶节点后跳出
+    while let Some(node) = cur.clone() {
+        match num.cmp(&node.borrow().val) {
+            // 目标节点在 cur 的右子树中
+            Ordering::Greater => cur = node.borrow().right.clone(),
+            // 目标节点在 cur 的左子树中
+            Ordering::Less => cur = node.borrow().left.clone(),
+            // 找到目标节点，跳出循环
+            Ordering::Equal => break,
+        }
+    }
+
+    // 返回目标节点
+    cur
+}
+
    +
    +
    +
    binary_search_tree.c
    /* 查找节点 */
+TreeNode *search(BinarySearchTree *bst, int num) {
+    TreeNode *cur = bst->root;
+    // 循环查找，越过叶节点后跳出
+    while (cur != NULL) {
+        if (cur->val < num) {
+            // 目标节点在 cur 的右子树中
+            cur = cur->right;
+        } else if (cur->val > num) {
+            // 目标节点在 cur 的左子树中
+            cur = cur->left;
+        } else {
+            // 找到目标节点，跳出循环
+            break;
+        }
+    }
+    // 返回目标节点
+    return cur;
+}
+
    +
    +
    +
    binary_search_tree.kt
    /* 查找节点 */
+fun search(num: Int): TreeNode? {
+    var cur = root
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 目标节点在 cur 的右子树中
+        cur = if (cur.value < num) cur.right
+        // 目标节点在 cur 的左子树中
+        else if (cur.value > num) cur.left
+        // 找到目标节点，跳出循环
+        else break
+    }
+    // 返回目标节点
+    return cur
+}
+
    +
    +
    +
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{search}
+
    +
    +
    +
    binary_search_tree.zig
    // 查找节点
+fn search(self: *Self, num: T) ?*inc.TreeNode(T) {
+    var cur = self.root;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 目标节点在 cur 的右子树中
+        if (cur.?.val < num) {
+            cur = cur.?.right;
+        // 目标节点在 cur 的左子树中
+        } else if (cur.?.val > num) {
+            cur = cur.?.left;
+        // 找到目标节点，跳出循环
+        } else {
+            break;
+        }
+    }
+    // 返回目标节点
+    return cur;
+}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    2.   Inserting a node

    +

    Given an element num to be inserted, to maintain the property of the binary search tree "left subtree < root node < right subtree," the insertion operation proceeds as shown in the Figure 7-18 .

    +
      +
    1. Finding the insertion position: Similar to the search operation, start from the root node and loop downwards according to the size relationship between the current node value and num until passing through the leaf node (traversing to None) then exit the loop.
      2. +
    2. Insert the node at that position: Initialize the node num and place it where None was.
      3. +
    +

    Inserting a node into a binary search tree

    +

    Figure 7-18   Inserting a node into a binary search tree

    + +

    In the code implementation, note the following two points.

    +
      +
    • The binary search tree does not allow duplicate nodes; otherwise, it will violate its definition. Therefore, if the node to be inserted already exists in the tree, the insertion is not performed, and it directly returns.
      • +
    • To perform the insertion operation, we need to use the node pre to save the node from the last loop. This way, when traversing to None, we can get its parent node, thus completing the node insertion operation.
      • +
    +
    +
    +
    +
    binary_search_tree.py
    def insert(self, num: int):
+    """插入节点"""
+    # 若树为空，则初始化根节点
+    if self._root is None:
+        self._root = TreeNode(num)
+        return
+    # 循环查找，越过叶节点后跳出
+    cur, pre = self._root, None
+    while cur is not None:
+        # 找到重复节点，直接返回
+        if cur.val == num:
+            return
+        pre = cur
+        # 插入位置在 cur 的右子树中
+        if cur.val < num:
+            cur = cur.right
+        # 插入位置在 cur 的左子树中
+        else:
+            cur = cur.left
+    # 插入节点
+    node = TreeNode(num)
+    if pre.val < num:
+        pre.right = node
+    else:
+        pre.left = node
+
    +
    +
    +
    binary_search_tree.cpp
    /* 插入节点 */
+void insert(int num) {
+    // 若树为空，则初始化根节点
+    if (root == nullptr) {
+        root = new TreeNode(num);
+        return;
+    }
+    TreeNode *cur = root, *pre = nullptr;
+    // 循环查找，越过叶节点后跳出
+    while (cur != nullptr) {
+        // 找到重复节点，直接返回
+        if (cur->val == num)
+            return;
+        pre = cur;
+        // 插入位置在 cur 的右子树中
+        if (cur->val < num)
+            cur = cur->right;
+        // 插入位置在 cur 的左子树中
+        else
+            cur = cur->left;
+    }
+    // 插入节点
+    TreeNode *node = new TreeNode(num);
+    if (pre->val < num)
+        pre->right = node;
+    else
+        pre->left = node;
+}
+
    +
    +
    +
    binary_search_tree.java
    /* 插入节点 */
+void insert(int num) {
+    // 若树为空，则初始化根节点
+    if (root == null) {
+        root = new TreeNode(num);
+        return;
+    }
+    TreeNode cur = root, pre = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 找到重复节点，直接返回
+        if (cur.val == num)
+            return;
+        pre = cur;
+        // 插入位置在 cur 的右子树中
+        if (cur.val < num)
+            cur = cur.right;
+        // 插入位置在 cur 的左子树中
+        else
+            cur = cur.left;
+    }
+    // 插入节点
+    TreeNode node = new TreeNode(num);
+    if (pre.val < num)
+        pre.right = node;
+    else
+        pre.left = node;
+}
+
    +
    +
    +
    binary_search_tree.cs
    /* 插入节点 */
+void Insert(int num) {
+    // 若树为空，则初始化根节点
+    if (root == null) {
+        root = new TreeNode(num);
+        return;
+    }
+    TreeNode? cur = root, pre = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 找到重复节点，直接返回
+        if (cur.val == num)
+            return;
+        pre = cur;
+        // 插入位置在 cur 的右子树中
+        if (cur.val < num)
+            cur = cur.right;
+        // 插入位置在 cur 的左子树中
+        else
+            cur = cur.left;
+    }
+
+    // 插入节点
+    TreeNode node = new(num);
+    if (pre != null) {
+        if (pre.val < num)
+            pre.right = node;
+        else
+            pre.left = node;
+    }
+}
+
    +
    +
    +
    binary_search_tree.go
    /* 插入节点 */
+func (bst *binarySearchTree) insert(num int) {
+    cur := bst.root
+    // 若树为空，则初始化根节点
+    if cur == nil {
+        bst.root = NewTreeNode(num)
+        return
+    }
+    // 待插入节点之前的节点位置
+    var pre *TreeNode = nil
+    // 循环查找，越过叶节点后跳出
+    for cur != nil {
+        if cur.Val == num {
+            return
+        }
+        pre = cur
+        if cur.Val.(int) < num {
+            cur = cur.Right
+        } else {
+            cur = cur.Left
+        }
+    }
+    // 插入节点
+    node := NewTreeNode(num)
+    if pre.Val.(int) < num {
+        pre.Right = node
+    } else {
+        pre.Left = node
+    }
+}
+
    +
    +
    +
    binary_search_tree.swift
    /* 插入节点 */
+func insert(num: Int) {
+    // 若树为空，则初始化根节点
+    if root == nil {
+        root = TreeNode(x: num)
+        return
+    }
+    var cur = root
+    var pre: TreeNode?
+    // 循环查找，越过叶节点后跳出
+    while cur != nil {
+        // 找到重复节点，直接返回
+        if cur!.val == num {
+            return
+        }
+        pre = cur
+        // 插入位置在 cur 的右子树中
+        if cur!.val < num {
+            cur = cur?.right
+        }
+        // 插入位置在 cur 的左子树中
+        else {
+            cur = cur?.left
+        }
+    }
+    // 插入节点
+    let node = TreeNode(x: num)
+    if pre!.val < num {
+        pre?.right = node
+    } else {
+        pre?.left = node
+    }
+}
+
    +
    +
    +
    binary_search_tree.js
    /* 插入节点 */
+insert(num) {
+    // 若树为空，则初始化根节点
+    if (this.root === null) {
+        this.root = new TreeNode(num);
+        return;
+    }
+    let cur = this.root,
+        pre = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur !== null) {
+        // 找到重复节点，直接返回
+        if (cur.val === num) return;
+        pre = cur;
+        // 插入位置在 cur 的右子树中
+        if (cur.val < num) cur = cur.right;
+        // 插入位置在 cur 的左子树中
+        else cur = cur.left;
+    }
+    // 插入节点
+    const node = new TreeNode(num);
+    if (pre.val < num) pre.right = node;
+    else pre.left = node;
+}
+
    +
    +
    +
    binary_search_tree.ts
    /* 插入节点 */
+insert(num: number): void {
+    // 若树为空，则初始化根节点
+    if (this.root === null) {
+        this.root = new TreeNode(num);
+        return;
+    }
+    let cur: TreeNode | null = this.root,
+        pre: TreeNode | null = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur !== null) {
+        // 找到重复节点，直接返回
+        if (cur.val === num) return;
+        pre = cur;
+        // 插入位置在 cur 的右子树中
+        if (cur.val < num) cur = cur.right;
+        // 插入位置在 cur 的左子树中
+        else cur = cur.left;
+    }
+    // 插入节点
+    const node = new TreeNode(num);
+    if (pre!.val < num) pre!.right = node;
+    else pre!.left = node;
+}
+
    +
    +
    +
    binary_search_tree.dart
    /* 插入节点 */
+void insert(int _num) {
+  // 若树为空，则初始化根节点
+  if (_root == null) {
+    _root = TreeNode(_num);
+    return;
+  }
+  TreeNode? cur = _root;
+  TreeNode? pre = null;
+  // 循环查找，越过叶节点后跳出
+  while (cur != null) {
+    // 找到重复节点，直接返回
+    if (cur.val == _num) return;
+    pre = cur;
+    // 插入位置在 cur 的右子树中
+    if (cur.val < _num)
+      cur = cur.right;
+    // 插入位置在 cur 的左子树中
+    else
+      cur = cur.left;
+  }
+  // 插入节点
+  TreeNode? node = TreeNode(_num);
+  if (pre!.val < _num)
+    pre.right = node;
+  else
+    pre.left = node;
+}
+
    +
    +
    +
    binary_search_tree.rs
    /* 插入节点 */
+pub fn insert(&mut self, num: i32) {
+    // 若树为空，则初始化根节点
+    if self.root.is_none() {
+        self.root = Some(TreeNode::new(num));
+        return;
+    }
+    let mut cur = self.root.clone();
+    let mut pre = None;
+    // 循环查找，越过叶节点后跳出
+    while let Some(node) = cur.clone() {
+        match num.cmp(&node.borrow().val) {
+            // 找到重复节点，直接返回
+            Ordering::Equal => return,
+            // 插入位置在 cur 的右子树中
+            Ordering::Greater => {
+                pre = cur.clone();
+                cur = node.borrow().right.clone();
+            }
+            // 插入位置在 cur 的左子树中
+            Ordering::Less => {
+                pre = cur.clone();
+                cur = node.borrow().left.clone();
+            }
+        }
+    }
+    // 插入节点
+    let pre = pre.unwrap();
+    let node = Some(TreeNode::new(num));
+    if num > pre.borrow().val {
+        pre.borrow_mut().right = node;
+    } else {
+        pre.borrow_mut().left = node;
+    }
+}
+
    +
    +
    +
    binary_search_tree.c
    /* 插入节点 */
+void insert(BinarySearchTree *bst, int num) {
+    // 若树为空，则初始化根节点
+    if (bst->root == NULL) {
+        bst->root = newTreeNode(num);
+        return;
+    }
+    TreeNode *cur = bst->root, *pre = NULL;
+    // 循环查找，越过叶节点后跳出
+    while (cur != NULL) {
+        // 找到重复节点，直接返回
+        if (cur->val == num) {
+            return;
+        }
+        pre = cur;
+        if (cur->val < num) {
+            // 插入位置在 cur 的右子树中
+            cur = cur->right;
+        } else {
+            // 插入位置在 cur 的左子树中
+            cur = cur->left;
+        }
+    }
+    // 插入节点
+    TreeNode *node = newTreeNode(num);
+    if (pre->val < num) {
+        pre->right = node;
+    } else {
+        pre->left = node;
+    }
+}
+
    +
    +
    +
    binary_search_tree.kt
    /* 插入节点 */
+fun insert(num: Int) {
+    // 若树为空，则初始化根节点
+    if (root == null) {
+        root = TreeNode(num)
+        return
+    }
+    var cur = root
+    var pre: TreeNode? = null
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 找到重复节点，直接返回
+        if (cur.value == num) return
+        pre = cur
+        // 插入位置在 cur 的右子树中
+        cur = if (cur.value < num) cur.right
+        // 插入位置在 cur 的左子树中
+        else cur.left
+    }
+    // 插入节点
+    val node = TreeNode(num)
+    if (pre?.value!! < num) pre.right = node
+    else pre.left = node
+}
+
    +
    +
    +
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{insert}
+
    +
    +
    +
    binary_search_tree.zig
    // 插入节点
+fn insert(self: *Self, num: T) !void {
+    // 若树为空，则初始化根节点
+    if (self.root == null) {
+        self.root = try self.mem_allocator.create(inc.TreeNode(T));
+        return;
+    }
+    var cur = self.root;
+    var pre: ?*inc.TreeNode(T) = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 找到重复节点，直接返回
+        if (cur.?.val == num) return;
+        pre = cur;
+        // 插入位置在 cur 的右子树中
+        if (cur.?.val < num) {
+            cur = cur.?.right;
+        // 插入位置在 cur 的左子树中
+        } else {
+            cur = cur.?.left;
+        }
+    }
+    // 插入节点
+    var node = try self.mem_allocator.create(inc.TreeNode(T));
+    node.init(num);
+    if (pre.?.val < num) {
+        pre.?.right = node;
+    } else {
+        pre.?.left = node;
+    }
+}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    Similar to searching for a node, inserting a node uses \(O(\log n)\) time.

    +

    3.   Removing a node

    +

    First, find the target node in the binary tree, then remove it. Similar to inserting a node, we need to ensure that after the removal operation is completed, the property of the binary search tree "left subtree < root node < right subtree" is still satisfied. Therefore, based on the number of child nodes of the target node, we divide it into 0, 1, and 2 cases, performing the corresponding node removal operations.

    +

    As shown in the Figure 7-19 , when the degree of the node to be removed is \(0\), it means the node is a leaf node, and it can be directly removed.

    +

    Removing a node in a binary search tree (degree 0)

    +

    Figure 7-19   Removing a node in a binary search tree (degree 0)

    + +

    As shown in the Figure 7-20 , when the degree of the node to be removed is \(1\), replacing the node to be removed with its child node is sufficient.

    +

    Removing a node in a binary search tree (degree 1)

    +

    Figure 7-20   Removing a node in a binary search tree (degree 1)

    + +

    When the degree of the node to be removed is \(2\), we cannot remove it directly, but need to use a node to replace it. To maintain the property of the binary search tree "left subtree < root node < right subtree," this node can be either the smallest node of the right subtree or the largest node of the left subtree.

    +

    Assuming we choose the smallest node of the right subtree (the next node in in-order traversal), then the removal operation proceeds as shown in the Figure 7-21 .

    +
      +
    1. Find the next node in the "in-order traversal sequence" of the node to be removed, denoted as tmp.
      2. +
    2. Replace the value of the node to be removed with tmp's value, and recursively remove the node tmp in the tree.
      3. +
    +
    +
    +
    +

    Removing a node in a binary search tree (degree 2)

    +
    +
    +

    bst_remove_case3_step2

    +
    +
    +

    bst_remove_case3_step3

    +
    +
    +

    bst_remove_case3_step4

    +
    +
    +
    +

    Figure 7-21   Removing a node in a binary search tree (degree 2)

    + +

    The operation of removing a node also uses \(O(\log n)\) time, where finding the node to be removed requires \(O(\log n)\) time, and obtaining the in-order traversal successor node requires \(O(\log n)\) time. Example code is as follows:

    +
    +
    +
    +
    binary_search_tree.py
    def remove(self, num: int):
+    """删除节点"""
+    # 若树为空，直接提前返回
+    if self._root is None:
+        return
+    # 循环查找，越过叶节点后跳出
+    cur, pre = self._root, None
+    while cur is not None:
+        # 找到待删除节点，跳出循环
+        if cur.val == num:
+            break
+        pre = cur
+        # 待删除节点在 cur 的右子树中
+        if cur.val < num:
+            cur = cur.right
+        # 待删除节点在 cur 的左子树中
+        else:
+            cur = cur.left
+    # 若无待删除节点，则直接返回
+    if cur is None:
+        return
+
+    # 子节点数量 = 0 or 1
+    if cur.left is None or cur.right is None:
+        # 当子节点数量 = 0 / 1 时， child = null / 该子节点
+        child = cur.left or cur.right
+        # 删除节点 cur
+        if cur != self._root:
+            if pre.left == cur:
+                pre.left = child
+            else:
+                pre.right = child
+        else:
+            # 若删除节点为根节点，则重新指定根节点
+            self._root = child
+    # 子节点数量 = 2
+    else:
+        # 获取中序遍历中 cur 的下一个节点
+        tmp: TreeNode = cur.right
+        while tmp.left is not None:
+            tmp = tmp.left
+        # 递归删除节点 tmp
+        self.remove(tmp.val)
+        # 用 tmp 覆盖 cur
+        cur.val = tmp.val
+
    +
    +
    +
    binary_search_tree.cpp
    /* 删除节点 */
+void remove(int num) {
+    // 若树为空，直接提前返回
+    if (root == nullptr)
+        return;
+    TreeNode *cur = root, *pre = nullptr;
+    // 循环查找，越过叶节点后跳出
+    while (cur != nullptr) {
+        // 找到待删除节点，跳出循环
+        if (cur->val == num)
+            break;
+        pre = cur;
+        // 待删除节点在 cur 的右子树中
+        if (cur->val < num)
+            cur = cur->right;
+        // 待删除节点在 cur 的左子树中
+        else
+            cur = cur->left;
+    }
+    // 若无待删除节点，则直接返回
+    if (cur == nullptr)
+        return;
+    // 子节点数量 = 0 or 1
+    if (cur->left == nullptr || cur->right == nullptr) {
+        // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
+        TreeNode *child = cur->left != nullptr ? cur->left : cur->right;
+        // 删除节点 cur
+        if (cur != root) {
+            if (pre->left == cur)
+                pre->left = child;
+            else
+                pre->right = child;
+        } else {
+            // 若删除节点为根节点，则重新指定根节点
+            root = child;
+        }
+        // 释放内存
+        delete cur;
+    }
+    // 子节点数量 = 2
+    else {
+        // 获取中序遍历中 cur 的下一个节点
+        TreeNode *tmp = cur->right;
+        while (tmp->left != nullptr) {
+            tmp = tmp->left;
+        }
+        int tmpVal = tmp->val;
+        // 递归删除节点 tmp
+        remove(tmp->val);
+        // 用 tmp 覆盖 cur
+        cur->val = tmpVal;
+    }
+}
+
    +
    +
    +
    binary_search_tree.java
    /* 删除节点 */
+void remove(int num) {
+    // 若树为空，直接提前返回
+    if (root == null)
+        return;
+    TreeNode cur = root, pre = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 找到待删除节点，跳出循环
+        if (cur.val == num)
+            break;
+        pre = cur;
+        // 待删除节点在 cur 的右子树中
+        if (cur.val < num)
+            cur = cur.right;
+        // 待删除节点在 cur 的左子树中
+        else
+            cur = cur.left;
+    }
+    // 若无待删除节点，则直接返回
+    if (cur == null)
+        return;
+    // 子节点数量 = 0 or 1
+    if (cur.left == null || cur.right == null) {
+        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
+        TreeNode child = cur.left != null ? cur.left : cur.right;
+        // 删除节点 cur
+        if (cur != root) {
+            if (pre.left == cur)
+                pre.left = child;
+            else
+                pre.right = child;
+        } else {
+            // 若删除节点为根节点，则重新指定根节点
+            root = child;
+        }
+    }
+    // 子节点数量 = 2
+    else {
+        // 获取中序遍历中 cur 的下一个节点
+        TreeNode tmp = cur.right;
+        while (tmp.left != null) {
+            tmp = tmp.left;
+        }
+        // 递归删除节点 tmp
+        remove(tmp.val);
+        // 用 tmp 覆盖 cur
+        cur.val = tmp.val;
+    }
+}
+
    +
    +
    +
    binary_search_tree.cs
    /* 删除节点 */
+void Remove(int num) {
+    // 若树为空，直接提前返回
+    if (root == null)
+        return;
+    TreeNode? cur = root, pre = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 找到待删除节点，跳出循环
+        if (cur.val == num)
+            break;
+        pre = cur;
+        // 待删除节点在 cur 的右子树中
+        if (cur.val < num)
+            cur = cur.right;
+        // 待删除节点在 cur 的左子树中
+        else
+            cur = cur.left;
+    }
+    // 若无待删除节点，则直接返回
+    if (cur == null)
+        return;
+    // 子节点数量 = 0 or 1
+    if (cur.left == null || cur.right == null) {
+        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
+        TreeNode? child = cur.left ?? cur.right;
+        // 删除节点 cur
+        if (cur != root) {
+            if (pre!.left == cur)
+                pre.left = child;
+            else
+                pre.right = child;
+        } else {
+            // 若删除节点为根节点，则重新指定根节点
+            root = child;
+        }
+    }
+    // 子节点数量 = 2
+    else {
+        // 获取中序遍历中 cur 的下一个节点
+        TreeNode? tmp = cur.right;
+        while (tmp.left != null) {
+            tmp = tmp.left;
+        }
+        // 递归删除节点 tmp
+        Remove(tmp.val!.Value);
+        // 用 tmp 覆盖 cur
+        cur.val = tmp.val;
+    }
+}
+
    +
    +
    +
    binary_search_tree.go
    /* 删除节点 */
+func (bst *binarySearchTree) remove(num int) {
+    cur := bst.root
+    // 若树为空，直接提前返回
+    if cur == nil {
+        return
+    }
+    // 待删除节点之前的节点位置
+    var pre *TreeNode = nil
+    // 循环查找，越过叶节点后跳出
+    for cur != nil {
+        if cur.Val == num {
+            break
+        }
+        pre = cur
+        if cur.Val.(int) < num {
+            // 待删除节点在右子树中
+            cur = cur.Right
+        } else {
+            // 待删除节点在左子树中
+            cur = cur.Left
+        }
+    }
+    // 若无待删除节点，则直接返回
+    if cur == nil {
+        return
+    }
+    // 子节点数为 0 或 1
+    if cur.Left == nil || cur.Right == nil {
+        var child *TreeNode = nil
+        // 取出待删除节点的子节点
+        if cur.Left != nil {
+            child = cur.Left
+        } else {
+            child = cur.Right
+        }
+        // 删除节点 cur
+        if cur != bst.root {
+            if pre.Left == cur {
+                pre.Left = child
+            } else {
+                pre.Right = child
+            }
+        } else {
+            // 若删除节点为根节点，则重新指定根节点
+            bst.root = child
+        }
+        // 子节点数为 2
+    } else {
+        // 获取中序遍历中待删除节点 cur 的下一个节点
+        tmp := cur.Right
+        for tmp.Left != nil {
+            tmp = tmp.Left
+        }
+        // 递归删除节点 tmp
+        bst.remove(tmp.Val.(int))
+        // 用 tmp 覆盖 cur
+        cur.Val = tmp.Val
+    }
+}
+
    +
    +
    +
    binary_search_tree.swift
    /* 删除节点 */
+func remove(num: Int) {
+    // 若树为空，直接提前返回
+    if root == nil {
+        return
+    }
+    var cur = root
+    var pre: TreeNode?
+    // 循环查找，越过叶节点后跳出
+    while cur != nil {
+        // 找到待删除节点，跳出循环
+        if cur!.val == num {
+            break
+        }
+        pre = cur
+        // 待删除节点在 cur 的右子树中
+        if cur!.val < num {
+            cur = cur?.right
+        }
+        // 待删除节点在 cur 的左子树中
+        else {
+            cur = cur?.left
+        }
+    }
+    // 若无待删除节点，则直接返回
+    if cur == nil {
+        return
+    }
+    // 子节点数量 = 0 or 1
+    if cur?.left == nil || cur?.right == nil {
+        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
+        let child = cur?.left ?? cur?.right
+        // 删除节点 cur
+        if cur !== root {
+            if pre?.left === cur {
+                pre?.left = child
+            } else {
+                pre?.right = child
+            }
+        } else {
+            // 若删除节点为根节点，则重新指定根节点
+            root = child
+        }
+    }
+    // 子节点数量 = 2
+    else {
+        // 获取中序遍历中 cur 的下一个节点
+        var tmp = cur?.right
+        while tmp?.left != nil {
+            tmp = tmp?.left
+        }
+        // 递归删除节点 tmp
+        remove(num: tmp!.val)
+        // 用 tmp 覆盖 cur
+        cur?.val = tmp!.val
+    }
+}
+
    +
    +
    +
    binary_search_tree.js
    /* 删除节点 */
+remove(num) {
+    // 若树为空，直接提前返回
+    if (this.root === null) return;
+    let cur = this.root,
+        pre = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur !== null) {
+        // 找到待删除节点，跳出循环
+        if (cur.val === num) break;
+        pre = cur;
+        // 待删除节点在 cur 的右子树中
+        if (cur.val < num) cur = cur.right;
+        // 待删除节点在 cur 的左子树中
+        else cur = cur.left;
+    }
+    // 若无待删除节点，则直接返回
+    if (cur === null) return;
+    // 子节点数量 = 0 or 1
+    if (cur.left === null || cur.right === null) {
+        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
+        const child = cur.left !== null ? cur.left : cur.right;
+        // 删除节点 cur
+        if (cur !== this.root) {
+            if (pre.left === cur) pre.left = child;
+            else pre.right = child;
+        } else {
+            // 若删除节点为根节点，则重新指定根节点
+            this.root = child;
+        }
+    }
+    // 子节点数量 = 2
+    else {
+        // 获取中序遍历中 cur 的下一个节点
+        let tmp = cur.right;
+        while (tmp.left !== null) {
+            tmp = tmp.left;
+        }
+        // 递归删除节点 tmp
+        this.remove(tmp.val);
+        // 用 tmp 覆盖 cur
+        cur.val = tmp.val;
+    }
+}
+
    +
    +
    +
    binary_search_tree.ts
    /* 删除节点 */
+remove(num: number): void {
+    // 若树为空，直接提前返回
+    if (this.root === null) return;
+    let cur: TreeNode | null = this.root,
+        pre: TreeNode | null = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur !== null) {
+        // 找到待删除节点，跳出循环
+        if (cur.val === num) break;
+        pre = cur;
+        // 待删除节点在 cur 的右子树中
+        if (cur.val < num) cur = cur.right;
+        // 待删除节点在 cur 的左子树中
+        else cur = cur.left;
+    }
+    // 若无待删除节点，则直接返回
+    if (cur === null) return;
+    // 子节点数量 = 0 or 1
+    if (cur.left === null || cur.right === null) {
+        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
+        const child: TreeNode | null =
+            cur.left !== null ? cur.left : cur.right;
+        // 删除节点 cur
+        if (cur !== this.root) {
+            if (pre!.left === cur) pre!.left = child;
+            else pre!.right = child;
+        } else {
+            // 若删除节点为根节点，则重新指定根节点
+            this.root = child;
+        }
+    }
+    // 子节点数量 = 2
+    else {
+        // 获取中序遍历中 cur 的下一个节点
+        let tmp: TreeNode | null = cur.right;
+        while (tmp!.left !== null) {
+            tmp = tmp!.left;
+        }
+        // 递归删除节点 tmp
+        this.remove(tmp!.val);
+        // 用 tmp 覆盖 cur
+        cur.val = tmp!.val;
+    }
+}
+
    +
    +
    +
    binary_search_tree.dart
    /* 删除节点 */
+void remove(int _num) {
+  // 若树为空，直接提前返回
+  if (_root == null) return;
+  TreeNode? cur = _root;
+  TreeNode? pre = null;
+  // 循环查找，越过叶节点后跳出
+  while (cur != null) {
+    // 找到待删除节点，跳出循环
+    if (cur.val == _num) break;
+    pre = cur;
+    // 待删除节点在 cur 的右子树中
+    if (cur.val < _num)
+      cur = cur.right;
+    // 待删除节点在 cur 的左子树中
+    else
+      cur = cur.left;
+  }
+  // 若无待删除节点，直接返回
+  if (cur == null) return;
+  // 子节点数量 = 0 or 1
+  if (cur.left == null || cur.right == null) {
+    // 当子节点数量 = 0 / 1 时， child = null / 该子节点
+    TreeNode? child = cur.left ?? cur.right;
+    // 删除节点 cur
+    if (cur != _root) {
+      if (pre!.left == cur)
+        pre.left = child;
+      else
+        pre.right = child;
+    } else {
+      // 若删除节点为根节点，则重新指定根节点
+      _root = child;
+    }
+  } else {
+    // 子节点数量 = 2
+    // 获取中序遍历中 cur 的下一个节点
+    TreeNode? tmp = cur.right;
+    while (tmp!.left != null) {
+      tmp = tmp.left;
+    }
+    // 递归删除节点 tmp
+    remove(tmp.val);
+    // 用 tmp 覆盖 cur
+    cur.val = tmp.val;
+  }
+}
+
    +
    +
    +
    binary_search_tree.rs
    /* 删除节点 */
+pub fn remove(&mut self, num: i32) {
+    // 若树为空，直接提前返回
+    if self.root.is_none() {
+        return;
+    }
+    let mut cur = self.root.clone();
+    let mut pre = None;
+    // 循环查找，越过叶节点后跳出
+    while let Some(node) = cur.clone() {
+        match num.cmp(&node.borrow().val) {
+            // 找到待删除节点，跳出循环
+            Ordering::Equal => break,
+            // 待删除节点在 cur 的右子树中
+            Ordering::Greater => {
+                pre = cur.clone();
+                cur = node.borrow().right.clone();
+            }
+            // 待删除节点在 cur 的左子树中
+            Ordering::Less => {
+                pre = cur.clone();
+                cur = node.borrow().left.clone();
+            }
+        }
+    }
+    // 若无待删除节点，则直接返回
+    if cur.is_none() {
+        return;
+    }
+    let cur = cur.unwrap();
+    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());
+    match (left_child.clone(), right_child.clone()) {
+        // 子节点数量 = 0 or 1
+        (None, None) | (Some(_), None) | (None, Some(_)) => {
+            // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
+            let child = left_child.or(right_child);
+            let pre = pre.unwrap();
+            // 删除节点 cur
+            if !Rc::ptr_eq(&cur, self.root.as_ref().unwrap()) {
+                let left = pre.borrow().left.clone();
+                if left.is_some() && Rc::ptr_eq(&left.as_ref().unwrap(), &cur) {
+                    pre.borrow_mut().left = child;
+                } else {
+                    pre.borrow_mut().right = child;
+                }
+            } else {
+                // 若删除节点为根节点，则重新指定根节点
+                self.root = child;
+            }
+        }
+        // 子节点数量 = 2
+        (Some(_), Some(_)) => {
+            // 获取中序遍历中 cur 的下一个节点
+            let mut tmp = cur.borrow().right.clone();
+            while let Some(node) = tmp.clone() {
+                if node.borrow().left.is_some() {
+                    tmp = node.borrow().left.clone();
+                } else {
+                    break;
+                }
+            }
+            let tmpval = tmp.unwrap().borrow().val;
+            // 递归删除节点 tmp
+            self.remove(tmpval);
+            // 用 tmp 覆盖 cur
+            cur.borrow_mut().val = tmpval;
+        }
+    }
+}
+
    +
    +
    +
    binary_search_tree.c
    /* 删除节点 */
+// 由于引入了 stdio.h ，此处无法使用 remove 关键词
+void removeItem(BinarySearchTree *bst, int num) {
+    // 若树为空，直接提前返回
+    if (bst->root == NULL)
+        return;
+    TreeNode *cur = bst->root, *pre = NULL;
+    // 循环查找，越过叶节点后跳出
+    while (cur != NULL) {
+        // 找到待删除节点，跳出循环
+        if (cur->val == num)
+            break;
+        pre = cur;
+        if (cur->val < num) {
+            // 待删除节点在 root 的右子树中
+            cur = cur->right;
+        } else {
+            // 待删除节点在 root 的左子树中
+            cur = cur->left;
+        }
+    }
+    // 若无待删除节点，则直接返回
+    if (cur == NULL)
+        return;
+    // 判断待删除节点是否存在子节点
+    if (cur->left == NULL || cur->right == NULL) {
+        /* 子节点数量 = 0 or 1 */
+        // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
+        TreeNode *child = cur->left != NULL ? cur->left : cur->right;
+        // 删除节点 cur
+        if (pre->left == cur) {
+            pre->left = child;
+        } else {
+            pre->right = child;
+        }
+        // 释放内存
+        free(cur);
+    } else {
+        /* 子节点数量 = 2 */
+        // 获取中序遍历中 cur 的下一个节点
+        TreeNode *tmp = cur->right;
+        while (tmp->left != NULL) {
+            tmp = tmp->left;
+        }
+        int tmpVal = tmp->val;
+        // 递归删除节点 tmp
+        removeItem(bst, tmp->val);
+        // 用 tmp 覆盖 cur
+        cur->val = tmpVal;
+    }
+}
+
    +
    +
    +
    binary_search_tree.kt
    /* 删除节点 */
+fun remove(num: Int) {
+    // 若树为空，直接提前返回
+    if (root == null) return
+    var cur = root
+    var pre: TreeNode? = null
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 找到待删除节点，跳出循环
+        if (cur.value == num) break
+        pre = cur
+        // 待删除节点在 cur 的右子树中
+        cur = if (cur.value < num) cur.right
+        // 待删除节点在 cur 的左子树中
+        else cur.left
+    }
+    // 若无待删除节点，则直接返回
+    if (cur == null) return
+    // 子节点数量 = 0 or 1
+    if (cur.left == null || cur.right == null) {
+        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
+        val child = if (cur.left != null) cur.left else cur.right
+        // 删除节点 cur
+        if (cur != root) {
+            if (pre!!.left == cur) pre.left = child
+            else pre.right = child
+        } else {
+            // 若删除节点为根节点，则重新指定根节点
+            root = child
+        }
+        // 子节点数量 = 2
+    } else {
+        // 获取中序遍历中 cur 的下一个节点
+        var tmp = cur.right
+        while (tmp!!.left != null) {
+            tmp = tmp.left
+        }
+        // 递归删除节点 tmp
+        remove(tmp.value)
+        // 用 tmp 覆盖 cur
+        cur.value = tmp.value
+    }
+}
+
    +
    +
    +
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{remove}
+
    +
    +
    +
    binary_search_tree.zig
    // 删除节点
+fn remove(self: *Self, num: T) void {
+    // 若树为空，直接提前返回
+    if (self.root == null) return;
+    var cur = self.root;
+    var pre: ?*inc.TreeNode(T) = null;
+    // 循环查找，越过叶节点后跳出
+    while (cur != null) {
+        // 找到待删除节点，跳出循环
+        if (cur.?.val == num) break;
+        pre = cur;
+        // 待删除节点在 cur 的右子树中
+        if (cur.?.val < num) {
+            cur = cur.?.right;
+        // 待删除节点在 cur 的左子树中
+        } else {
+            cur = cur.?.left;
+        }
+    }
+    // 若无待删除节点，则直接返回
+    if (cur == null) return;
+    // 子节点数量 = 0 or 1
+    if (cur.?.left == null or cur.?.right == null) {
+        // 当子节点数量 = 0 / 1 时， child = null / 该子节点
+        var child = if (cur.?.left != null) cur.?.left else cur.?.right;
+        // 删除节点 cur
+        if (pre.?.left == cur) {
+            pre.?.left = child;
+        } else {
+            pre.?.right = child;
+        }
+    // 子节点数量 = 2
+    } else {
+        // 获取中序遍历中 cur 的下一个节点
+        var tmp = cur.?.right;
+        while (tmp.?.left != null) {
+            tmp = tmp.?.left;
+        }
+        var tmp_val = tmp.?.val;
+        // 递归删除节点 tmp
+        self.remove(tmp.?.val);
+        // 用 tmp 覆盖 cur
+        cur.?.val = tmp_val;
+    }
+}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    4.   In-order traversal is ordered

    +

    As shown in the Figure 7-22 , the in-order traversal of a binary tree follows the "left \(\rightarrow\) root \(\rightarrow\) right" traversal order, and a binary search tree satisfies the size relationship "left child node < root node < right child node".

    +

    This means that in-order traversal in a binary search tree always traverses the next smallest node first, thus deriving an important property: The in-order traversal sequence of a binary search tree is ascending.

    +

    Using the ascending property of in-order traversal, obtaining ordered data in a binary search tree requires only \(O(n)\) time, without the need for additional sorting operations, which is very efficient.

    +

    In-order traversal sequence of a binary search tree

    +

    Figure 7-22   In-order traversal sequence of a binary search tree

    + +

    7.4.2   Efficiency of binary search trees

    +

    Given a set of data, we consider using an array or a binary search tree for storage. Observing the Table 7-2 , the operations on a binary search tree all have logarithmic time complexity, which is stable and efficient. Only in scenarios of high-frequency addition and low-frequency search and removal, arrays are more efficient than binary search trees.

    +

    Table 7-2   Efficiency comparison between arrays and search trees

    + +
    + + + + + + + + + + + + + + + + + + + + + + + + + +
    Unsorted arrayBinary search tree
    Search element\(O(n)\)\(O(\log n)\)
    Insert element\(O(1)\)\(O(\log n)\)
    Remove element\(O(n)\)\(O(\log n)\)
    +
    +

    In ideal conditions, the binary search tree is "balanced," thus any node can be found within \(\log n\) loops.

    +

    However, continuously inserting and removing nodes in a binary search tree may lead to the binary tree degenerating into a chain list as shown in the Figure 7-23 , at which point the time complexity of various operations also degrades to \(O(n)\).

    +

    Degradation of a binary search tree

    +

    Figure 7-23   Degradation of a binary search tree

    + +

    7.4.3   Common applications of binary search trees

    +
      +
    • Used as multi-level indexes in systems to implement efficient search, insertion, and removal operations.
      • +
    • Serves as the underlying data structure for certain search algorithms.
      • +
    • Used to store data streams to maintain their ordered state.
      • +
    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_tree/binary_tree.assets/balanced_binary_tree.png b/en/chapter_tree/binary_tree.assets/balanced_binary_tree.png new file mode 100644 index 0000000000000000000000000000000000000000..64120ef5bb65be0ca8217120233ffc9a7e0be3fd GIT binary patch literal 16001 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 B)2RRe literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree.assets/binary_tree_add_remove.png b/en/chapter_tree/binary_tree.assets/binary_tree_add_remove.png new file mode 100644 index 0000000000000000000000000000000000000000..a0a9452723e519132b4081054a19702a0266bf58 GIT binary patch literal 20652 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree.assets/binary_tree_best_worst_cases.png b/en/chapter_tree/binary_tree.assets/binary_tree_best_worst_cases.png new file mode 100644 index 0000000000000000000000000000000000000000..acb42ce2f4c978c1bede975400179551c9412938 GIT binary patch literal 17221 zcmbSyRahKN6YlITPH+hB65K7gI|O%khakaWaSg6Pf(Hn}NpP0nuECw)9^4P#e|esB zb^2zitGeHMt9xsn*`AtcRTWt@6e1J=0MO*+q|^Zb{#67|AVFR)w?!Pe)8yi_!+4=eTwY9arwZ6o}M1Oz(^PBVD z-rl03qU-DHlGip`65bl7qoX4wCAGY~T>7mvr91ib^fazBRz*c+Z*T9{?9Z&e%$n)y z(9lpQ6#C`Mm&41$zh_&nuC5c?6FCDpl9H0M`?C!V4T}eh`}_O(`S}M22P0b}ZHsM@ z?Gdl-$K(%XW#!Py(3PX*u#&LyiSo7MwdvjIkjCKjAL$Vp5$XBqz2m+67#D;9Af7ER zC9dhcc+?gAx(NU@|EV0m9Q>d7|JO`EolrFXpg@4tg!N$hes^wVYS6<)X@6lj5b1Y9 zx}v#u?puqjbvdKf3q<(8Jj{<0XszTf7`+3X5%lf(7dgPec4Tgvy?OfhWx7%xyGf87 zk29ZIWZTqegJG+TTz-aj7V;D|Kj!X;i&_Ltswh6v1;a}3U7q{)m}C=&j)3{$J;mpW zi_Qa1H~}Px0by1E@`e`PJ0~=RpXymxY(W=r>0mH%xejU-7@Y7|yLN%DhRUI6n$}ok#cmrd_kxw6hcR2wtow&+*Ja>ed0l0-$2S|LaHem!V5hN}1h8UW;>U19w6;W9P+MyU&+AAfvn$w${m%MKmW zKMJ0+Kzx%gc1-g1Bm%Jj!w(+!6ATbw@ti}kT?Rq+_;tSi_)ZT6 zV&=4AGgi1_08dRWW4;;y!WHBBr6PvUfkFWtb6_$(;FXeMfC4S!zf@qjA3H)Is$iWI zCu_4fG1@EE1?h@iV90t@RDLISBx!@B4OZS2xK!KOhQ7`(W1Ufqj#M zfEZ41oO6ReRzp?Mq94azfYdD^bAAP_Mo+9gy3Zb-|1iWDuKloFmh5dfQ+8TLxOUI` zAIYI^M@CXPM=TXz2XnHTzgM&xl#XmAY>5K2?_>6!68osY8roQ|*xW=iIfEvpXk2

    wU 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree.assets/binary_tree_definition.png b/en/chapter_tree/binary_tree.assets/binary_tree_definition.png new file mode 100644 index 0000000000000000000000000000000000000000..51eed427766348999f1ed779dc9d9c235b5dcb74 GIT binary patch literal 24034 zcmbTdbyyVd8$LQ)bS$0X5(3hK5`wT2f)au#(k#+aODG@+L#Kd;R>C@BG)AOB; zp{2nO$;o+nc?SmvdwY9FM@Qr1B-1!^WNmG|ynQe@IQahk`{S*(lG3uG-olNI4SRe0%hlQ8zthEk zzAbF*^!E0S^mYHN!wqzI_O$<+o}TXN>N+3m#8p>4eE6`xzrTB~du(O&==5moaBF9I z;e7a4Q(ev5#@MfgMY&(|(?5P}YU?b@|EjC2J1{mW7Ted_*`1k@evs|I?W&O6ntX6_ zu)V$gwSVnO@bBg2<-c=F>vPkXuM^G9&DB*Et*xzv#ie#RwyV2GuCA_KeFGjI9?QGS zWB9qhYk$its>+AHmlqekZ;4-BU7eYkng2UBH9SyJR$4VuwK_A^H$2|a)Bmdxx8td* zqN1{{L%X>++x=%av^K=2#CsFNtDQO0x6mgL)!We0RyS7n_3PK*;Nab0gUYe3CH&v| zrq-s(#;@I9_TrvzSqU#JEF{z?7^WJG5A@gIni|G%KT3;J+fo7o0_IjXrxsRnKV>T_ zD&q0@ndSBA#kGvq^uY3fp!~oMLk{JX!GXnrPC}dRs4D-ypYpP!qvPaPnRn%kQ|Z(( zF3&CB6_ak(HMgJExw5o-da<>9zC10LFmP1cGdmBY_W1U^ z{OZk8Qc~O_$b(?YZt89PY4Fp^5lUCH0ptGqg8}XJ# z6A Dm&U~u0o$z8rqm=K9$KCU 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree.assets/binary_tree_terminology.png b/en/chapter_tree/binary_tree.assets/binary_tree_terminology.png new file mode 100644 index 0000000000000000000000000000000000000000..082bab825d0e5100ad01702ceaf7962b4e80067a GIT binary patch literal 20217 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree.assets/complete_binary_tree.png b/en/chapter_tree/binary_tree.assets/complete_binary_tree.png new file mode 100644 index 0000000000000000000000000000000000000000..74c033f28f5129089c49f9686bc0ae5421cd6bc1 GIT binary patch literal 14111 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 TgCA-aSRM3k8nC3+VFEy( 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�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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree.assets/perfect_binary_tree.png b/en/chapter_tree/binary_tree.assets/perfect_binary_tree.png new file mode 100644 index 0000000000000000000000000000000000000000..fea729b177e29a6927a264a1b5d34e092c20bc70 GIT binary patch literal 15374 zcmbWebyQT*_cwee7;<0)q+i;Ih;rKMlK zd|6&z-rwK9yt>TF%950nJUct<>FF6B9?rZ@<44;xMqXaNt*veQXxq`z@!;ej_gl`z#l`yix>cd2 zpP!$Vm6e5sML|J9%9j)w8JWq+$(ELu%F0S3BO_H+)jy|y+}zye=jRK%3TI|!^78V+ z!^4B#2YPsT93LOo*Vm7&j7>~TkNl zd3kJXtXHMy_wU~yKYsjUb9Q=qx}yJWQc{wRj!toLaZyoGKtMpvV6~Ex(#qaS_gr_z z*9^O2+sCi<&GXEprKQKm$0HjeHV-yUOiawp&HESnOM6TGYy7_b=x{4{9ay7ugWRQ!GFd7 zy9@PaLF(Vi?wk5sdiwv@SH$Os-TExi1#C}TpZec$e8(lftDU6zz$@>8)KiFoxBlq= zaPLCR>v_`7TT$RS-_JAIaZqDOPx{Vl-+FE(vkV2*RK^A_$T?U-AH@yhNk2C<>aBKloJi>!xd2dNAq^*7c7=q)WTl>SrKjxwdI7eQ` zz^NLG61*3dta&l_dd5~jLogyI{*7cu4I(t=ehxbXOP?%}b20qN`Ev8ztYL|PG7{0_ zOLuRnX+;sAvwS?;SS;rb0&h9#ivasBe&t!k%#(`4JOOPfWITKD2hrek@WhA?d;RyD ziJ8__O>l^ai{s;i$`m0=*O%r4$!YgU@jBdT(l(yEeR3*cQ{xamgajCP0a&Pza zXoEw#z{n#)ebQ5DX~5gFmUY_T<;Z%SyT`FGpw@KkGot!9Q>(Bcy zmz1kS>Ab5gAC1p_muot3h~Pu>0IXRO(}|M4C~&AKiMaX~ilPu(u=%x7Jd8n12g`s- zwTl}h#dD%`**5}*cy(n4QI-xr6>#gm6orC$yyn_g@}OWc!Rc*TNX~}W{xo*#Hzqy! zIY~%!fcJInbKGWU2p_q;G9I#g_{489DDZCgw>Mr8_KLcI6F^&Nt{V4yJ zVaZ4&)eEZO1xeEwyZvPf7A z2^f3xZ|}Av%6NCdjV`!XBsYc+(9bJuI1r{n=r7-8vUGS1)18gI=^)_V&V!J0pQn|~G&&x+xVNydzzYd9b9~3&3>R)sK zc)cE5lGTr=yMAQ>pU}+;Aa{pk5TPsS+&AEcqdlw;q&?Axg_=C< zgsIro!N(iI*F@+-I*XoZN@_sfcX4U(BIx`TD3QFKYdWACVC&@@`L(q=>V41yD8+v0 zGN14}WP;?EdFMSS+D*$zXzd1+4ruJsZw^=>NOpycv)Q(U)i6z%lnznwgY#qm3m!>+ zAoiI=5W`iaIpd*CRZj0-1|uy0mGk$(T31`i5zfxF?B|Z#YLVBs0YQ)NT{EtiHy(MG z9bMT22ABubLG?92^z`Zvhi&%@{)=0JCwvMS&I9Rry3{iUK!=lK`Tjeb`4RELNQp-S z-jYXVK^oR}<{&NItORkzAKUVs^MjJVTfwjIt6g|4GqC&n1@)FuhVZQUfyq|CRdd2THe{*Z(T}i;HeX z4y8@3^TGM62dlaty-&~_f5|AL8h?j1{#%EIw37V#XX0W&@$|mhU$D)WGd%N%aw0vT zqjEqo2&WP&jr}jFqq3RtfCGgEB3C~OF&^LE(}bN7pfi_NSB_1;;PcV>$P zpGM?He2n8Xy_Xf*!9@EUM9B^2#$jqq3Sf)RfBBL(ICx&Y@U+T0cHnT1(X*sDhn=o_ zk;+^l^VwN+9-1z!BtM0BWzl?}EYWg^JcYEx?_Bj9%J~$L7pgOo&COUq(&0{&8LIPj zuj(fAr-Hv!m1V6kPVt*XTS^Bb7U6L*n7^);3RSD2;|xo~*h82xc9eOrLPK^Xf!CGK z&UUwd@!(bfdE{U6q!JT}U#!S~YPF_-4o#_-(tqLq!;|qv^Nppb|9E1=#kjas8Z8|_ zprY*YDIi<|VbF;b$MKJ_XMOWP>`g|A9BUqwQdOG7<;KwZb%wt%0A_YkMt=b69<|UBhw-4 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 agQz7`aH=(9Yw-~KJ64w0kgJwKh5kRMA?pSJ literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree/index.html b/en/chapter_tree/binary_tree/index.html new file mode 100644 index 000000000..179c51cd1 --- /dev/null +++ b/en/chapter_tree/binary_tree/index.html @@ -0,0 +1,3098 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 7.1 Binary Tree - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

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

    7.1   Binary tree

    +

    A "binary tree" is a non-linear data structure that represents the ancestral and descendent relationships, embodying the "divide and conquer" logic. Similar to a linked list, the basic unit of a binary tree is a node, each containing a value, a reference to the left child node, and a reference to the right child node.

    +
    +
    +
    +
    class TreeNode:
+    """Binary tree node"""
+    def __init__(self, val: int):
+        self.val: int = val                # Node value
+        self.left: TreeNode | None = None  # Reference to left child node
+        self.right: TreeNode | None = None # Reference to right child node
+
    +
    +
    +
    /* Binary tree node */
+struct TreeNode {
+    int val;          // Node value
+    TreeNode *left;   // Pointer to left child node
+    TreeNode *right;  // Pointer to right child node
+    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+};
+
    +
    +
    +
    /* Binary tree node */
+class TreeNode {
+    int val;         // Node value
+    TreeNode left;   // Reference to left child node
+    TreeNode right;  // Reference to right child node
+    TreeNode(int x) { val = x; }
+}
+
    +
    +
    +
    /* Binary tree node */
+class TreeNode(int? x) {
+    public int? val = x;    // Node value
+    public TreeNode? left;  // Reference to left child node
+    public TreeNode? right; // Reference to right child node
+}
+
    +
    +
    +
    /* Binary tree node */
+type TreeNode struct {
+    Val   int
+    Left  *TreeNode
+    Right *TreeNode
+}
+/* 构造方法 */
+func NewTreeNode(v int) *TreeNode {
+    return &TreeNode{
+        Left:  nil, // Pointer to left child node
+        Right: nil, // Pointer to right child node
+        Val:   v,   // Node value
+    }
+}
+
    +
    +
    +
    /* Binary tree node */
+class TreeNode {
+    var val: Int // Node value
+    var left: TreeNode? // Reference to left child node
+    var right: TreeNode? // Reference to right child node
+
+    init(x: Int) {
+        val = x
+    }
+}
+
    +
    +
    +
    /* Binary tree node */
+class TreeNode {
+    val; // Node value
+    left; // Pointer to left child node
+    right; // Pointer to right child node
+    constructor(val, left, right) {
+        this.val = val === undefined ? 0 : val;
+        this.left = left === undefined ? null : left;
+        this.right = right === undefined ? null : right;
+    }
+}
+
    +
    +
    +
    /* Binary tree node */
+class TreeNode {
+    val: number;
+    left: TreeNode | null;
+    right: TreeNode | null;
+
+    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = val === undefined ? 0 : val; // Node value
+        this.left = left === undefined ? null : left; // Reference to left child node
+        this.right = right === undefined ? null : right; // Reference to right child node
+    }
+}
+
    +
    +
    +
    /* Binary tree node */
+class TreeNode {
+  int val;         // Node value
+  TreeNode? left;  // Reference to left child node
+  TreeNode? right; // Reference to right child node
+  TreeNode(this.val, [this.left, this.right]);
+}
+
    +
    +
    +
    use std::rc::Rc;
+use std::cell::RefCell;
+
+/* Binary tree node */
+struct TreeNode {
+    val: i32,                               // Node value
+    left: Option<Rc<RefCell<TreeNode>>>,    // Reference to left child node
+    right: Option<Rc<RefCell<TreeNode>>>,   // Reference to right child node
+}
+
+impl TreeNode {
+    /* 构造方法 */
+    fn new(val: i32) -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(Self {
+            val,
+            left: None,
+            right: None
+        }))
+    }
+}
+
    +
    +
    +
    /* Binary tree node */
+typedef struct TreeNode {
+    int val;                // Node value
+    int height;             // 节点高度
+    struct TreeNode *left;  // Pointer to left child node
+    struct TreeNode *right; // Pointer to right child node
+} TreeNode;
+
+/* 构造函数 */
+TreeNode *newTreeNode(int val) {
+    TreeNode *node;
+
+    node = (TreeNode *)malloc(sizeof(TreeNode));
+    node->val = val;
+    node->height = 0;
+    node->left = NULL;
+    node->right = NULL;
+    return node;
+}
+
    +
    +
    +
    /* Binary tree node */
+class TreeNode(val _val: Int) {  // Node value
+    val left: TreeNode? = null   // Reference to left child node
+    val right: TreeNode? = null  // Reference to right child node
+}
+
    +
    +
    +
    
+
    +
    +
    +
    
+
    +
    +
    +
    +

    Each node has two references (pointers), pointing to the "left-child node" and "right-child node," respectively. This node is called the "parent node" of these two child nodes. When given a node of a binary tree, we call the tree formed by this node's left child and all nodes under it the "left subtree" of this node. Similarly, the "right subtree" can be defined.

    +

    In a binary tree, except for leaf nodes, all other nodes contain child nodes and non-empty subtrees. As shown in the Figure 7-1 , if "Node 2" is considered as the parent node, then its left and right child nodes are "Node 4" and "Node 5," respectively. The left subtree is "the tree formed by Node 4 and all nodes under it," and the right subtree is "the tree formed by Node 5 and all nodes under it."

    +

    Parent Node, child Node, subtree

    +

    Figure 7-1   Parent Node, child Node, subtree

    + +

    7.1.1   Common terminology of binary trees

    +

    The commonly used terminology of binary trees is shown in the following figure.

    +
      +
    • "Root node": The node at the top level of the binary tree, which has no parent node.
      • +
    • "Leaf node": A node with no children, both of its pointers point to None.
      • +
    • "Edge": The line segment connecting two nodes, i.e., node reference (pointer).
      • +
    • The "level" of a node: Incrementing from top to bottom, with the root node's level being 1.
      • +
    • The "degree" of a node: The number of a node's children. In a binary tree, the degree can be 0, 1, or 2.
      • +
    • The "height" of a binary tree: The number of edges passed from the root node to the farthest leaf node.
      • +
    • The "depth" of a node: The number of edges passed from the root node to the node.
      • +
    • The "height" of a node: The number of edges from the farthest leaf node to the node.
      • +
    +

    Common Terminology of Binary Trees

    +

    Figure 7-2   Common Terminology of Binary Trees

    + +
    +

    Tip

    +

    Please note that we usually define "height" and "depth" as "the number of edges passed," but some problems or textbooks may define them as "the number of nodes passed." In this case, both height and depth need to be incremented by 1.

    +
    +

    7.1.2   Basic operations of binary trees

    +

    1.   Initializing a binary tree

    +

    Similar to a linked list, initialize nodes first, then construct references (pointers).

    +
    +
    +
    +
    binary_tree.py
    # Initializing a binary tree
+# Initializing nodes
+n1 = TreeNode(val=1)
+n2 = TreeNode(val=2)
+n3 = TreeNode(val=3)
+n4 = TreeNode(val=4)
+n5 = TreeNode(val=5)
+# Linking references (pointers) between nodes
+n1.left = n2
+n1.right = n3
+n2.left = n4
+n2.right = n5
+
    +
    +
    +
    binary_tree.cpp
    /* Initializing a binary tree */
+// Initializing nodes
+TreeNode* n1 = new TreeNode(1);
+TreeNode* n2 = new TreeNode(2);
+TreeNode* n3 = new TreeNode(3);
+TreeNode* n4 = new TreeNode(4);
+TreeNode* n5 = new TreeNode(5);
+// Linking references (pointers) between nodes
+n1->left = n2;
+n1->right = n3;
+n2->left = n4;
+n2->right = n5;
+
    +
    +
    +
    binary_tree.java
    // Initializing nodes
+TreeNode n1 = new TreeNode(1);
+TreeNode n2 = new TreeNode(2);
+TreeNode n3 = new TreeNode(3);
+TreeNode n4 = new TreeNode(4);
+TreeNode n5 = new TreeNode(5);
+// Linking references (pointers) between nodes
+n1.left = n2;
+n1.right = n3;
+n2.left = n4;
+n2.right = n5;
+
    +
    +
    +
    binary_tree.cs
    /* Initializing a binary tree */
+// Initializing nodes
+TreeNode n1 = new(1);
+TreeNode n2 = new(2);
+TreeNode n3 = new(3);
+TreeNode n4 = new(4);
+TreeNode n5 = new(5);
+// Linking references (pointers) between nodes
+n1.left = n2;
+n1.right = n3;
+n2.left = n4;
+n2.right = n5;
+
    +
    +
    +
    binary_tree.go
    /* Initializing a binary tree */
+// Initializing nodes
+n1 := NewTreeNode(1)
+n2 := NewTreeNode(2)
+n3 := NewTreeNode(3)
+n4 := NewTreeNode(4)
+n5 := NewTreeNode(5)
+// Linking references (pointers) between nodes
+n1.Left = n2
+n1.Right = n3
+n2.Left = n4
+n2.Right = n5
+
    +
    +
    +
    binary_tree.swift
    // Initializing nodes
+let n1 = TreeNode(x: 1)
+let n2 = TreeNode(x: 2)
+let n3 = TreeNode(x: 3)
+let n4 = TreeNode(x: 4)
+let n5 = TreeNode(x: 5)
+// Linking references (pointers) between nodes
+n1.left = n2
+n1.right = n3
+n2.left = n4
+n2.right = n5
+
    +
    +
    +
    binary_tree.js
    /* Initializing a binary tree */
+// Initializing nodes
+let n1 = new TreeNode(1),
+    n2 = new TreeNode(2),
+    n3 = new TreeNode(3),
+    n4 = new TreeNode(4),
+    n5 = new TreeNode(5);
+// Linking references (pointers) between nodes
+n1.left = n2;
+n1.right = n3;
+n2.left = n4;
+n2.right = n5;
+
    +
    +
    +
    binary_tree.ts
    /* Initializing a binary tree */
+// Initializing nodes
+let n1 = new TreeNode(1),
+    n2 = new TreeNode(2),
+    n3 = new TreeNode(3),
+    n4 = new TreeNode(4),
+    n5 = new TreeNode(5);
+// Linking references (pointers) between nodes
+n1.left = n2;
+n1.right = n3;
+n2.left = n4;
+n2.right = n5;
+
    +
    +
    +
    binary_tree.dart
    /* Initializing a binary tree */
+// Initializing nodes
+TreeNode n1 = new TreeNode(1);
+TreeNode n2 = new TreeNode(2);
+TreeNode n3 = new TreeNode(3);
+TreeNode n4 = new TreeNode(4);
+TreeNode n5 = new TreeNode(5);
+// Linking references (pointers) between nodes
+n1.left = n2;
+n1.right = n3;
+n2.left = n4;
+n2.right = n5;
+
    +
    +
    +
    binary_tree.rs
    // Initializing nodes
+let n1 = TreeNode::new(1);
+let n2 = TreeNode::new(2);
+let n3 = TreeNode::new(3);
+let n4 = TreeNode::new(4);
+let n5 = TreeNode::new(5);
+// Linking references (pointers) between nodes
+n1.borrow_mut().left = Some(n2.clone());
+n1.borrow_mut().right = Some(n3);
+n2.borrow_mut().left = Some(n4);
+n2.borrow_mut().right = Some(n5);
+
    +
    +
    +
    binary_tree.c
    /* Initializing a binary tree */
+// Initializing nodes
+TreeNode *n1 = newTreeNode(1);
+TreeNode *n2 = newTreeNode(2);
+TreeNode *n3 = newTreeNode(3);
+TreeNode *n4 = newTreeNode(4);
+TreeNode *n5 = newTreeNode(5);
+// Linking references (pointers) between nodes
+n1->left = n2;
+n1->right = n3;
+n2->left = n4;
+n2->right = n5;
+
    +
    +
    +
    binary_tree.kt
    // Initializing nodes
+val n1 = TreeNode(1)
+val n2 = TreeNode(2)
+val n3 = TreeNode(3)
+val n4 = TreeNode(4)
+val n5 = TreeNode(5)
+// Linking references (pointers) between nodes
+n1.left = n2
+n1.right = n3
+n2.left = n4
+n2.right = n5
+
    +
    +
    +
    binary_tree.rb
    
+
    +
    +
    +
    binary_tree.zig
    
+
    +
    +
    +
    +
    +Code visualization +

    https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false

    +
    +

    2.   Inserting and removing nodes

    +

    Similar to a linked list, inserting and removing nodes in a binary tree can be achieved by modifying pointers. The Figure 7-3 provides an example.

    +

    Inserting and removing nodes in a binary tree

    +

    Figure 7-3   Inserting and removing nodes in a binary tree

    + +
    +
    +
    +
    binary_tree.py
    # Inserting and removing nodes
+p = TreeNode(0)
+# Inserting node P between n1 -> n2
+n1.left = p
+p.left = n2
+# Removing node P
+n1.left = n2
+
    +
    +
    +
    binary_tree.cpp
    /* Inserting and removing nodes */
+TreeNode* P = new TreeNode(0);
+// Inserting node P between n1 and n2
+n1->left = P;
+P->left = n2;
+// Removing node P
+n1->left = n2;
+
    +
    +
    +
    binary_tree.java
    TreeNode P = new TreeNode(0);
+// Inserting node P between n1 and n2
+n1.left = P;
+P.left = n2;
+// Removing node P
+n1.left = n2;
+
    +
    +
    +
    binary_tree.cs
    /* Inserting and removing nodes */
+TreeNode P = new(0);
+// Inserting node P between n1 and n2
+n1.left = P;
+P.left = n2;
+// Removing node P
+n1.left = n2;
+
    +
    +
    +
    binary_tree.go
    /* Inserting and removing nodes */
+// Inserting node P between n1 and n2
+p := NewTreeNode(0)
+n1.Left = p
+p.Left = n2
+// Removing node P
+n1.Left = n2
+
    +
    +
    +
    binary_tree.swift
    let P = TreeNode(x: 0)
+// Inserting node P between n1 and n2
+n1.left = P
+P.left = n2
+// Removing node P
+n1.left = n2
+
    +
    +
    +
    binary_tree.js
    /* Inserting and removing nodes */
+let P = new TreeNode(0);
+// Inserting node P between n1 and n2
+n1.left = P;
+P.left = n2;
+// Removing node P
+n1.left = n2;
+
    +
    +
    +
    binary_tree.ts
    /* Inserting and removing nodes */
+const P = new TreeNode(0);
+// Inserting node P between n1 and n2
+n1.left = P;
+P.left = n2;
+// Removing node P
+n1.left = n2;
+
    +
    +
    +
    binary_tree.dart
    /* Inserting and removing nodes */
+TreeNode P = new TreeNode(0);
+// Inserting node P between n1 and n2
+n1.left = P;
+P.left = n2;
+// Removing node P
+n1.left = n2;
+
    +
    +
    +
    binary_tree.rs
    let p = TreeNode::new(0);
+// Inserting node P between n1 and n2
+n1.borrow_mut().left = Some(p.clone());
+p.borrow_mut().left = Some(n2.clone());
+// Removing node P
+n1.borrow_mut().left = Some(n2);
+
    +
    +
    +
    binary_tree.c
    /* Inserting and removing nodes */
+TreeNode *P = newTreeNode(0);
+// Inserting node P between n1 and n2
+n1->left = P;
+P->left = n2;
+// Removing node P
+n1->left = n2;
+
    +
    +
    +
    binary_tree.kt
    val P = TreeNode(0)
+// Inserting node P between n1 and n2
+n1.left = P
+P.left = n2
+// Removing node P
+n1.left = n2
+
    +
    +
    +
    binary_tree.rb
    
+
    +
    +
    +
    binary_tree.zig
    
+
    +
    +
    +
    +
    +Code visualization +

    https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5%0A%0A%20%20%20%20%23%20%E6%8F%92%E5%85%A5%E4%B8%8E%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%0A%20%20%20%20p%20%3D%20TreeNode%280%29%0A%20%20%20%20%23%20%E5%9C%A8%20n1%20-%3E%20n2%20%E4%B8%AD%E9%97%B4%E6%8F%92%E5%85%A5%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20p%0A%20%20%20%20p.left%20%3D%20n2%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20n2&cumulative=false&curInstr=37&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false

    +
    +
    +

    Note

    +

    It's important to note that inserting nodes may change the original logical structure of the binary tree, while removing nodes usually means removing the node and all its subtrees. Therefore, in a binary tree, insertion and removal are usually performed through a set of operations to achieve meaningful actions.

    +
    +

    7.1.3   Common types of binary trees

    +

    1.   Perfect binary tree

    +

    As shown in the Figure 7-4 , in a "perfect binary tree," all levels of nodes are fully filled. In a perfect binary tree, the degree of leaf nodes is \(0\), and the degree of all other nodes is \(2\); if the tree's height is \(h\), then the total number of nodes is \(2^{h+1} - 1\), showing a standard exponential relationship, reflecting the common phenomenon of cell division in nature.

    +
    +

    Tip

    +

    Please note that in the Chinese community, a perfect binary tree is often referred to as a "full binary tree."

    +
    +

    Perfect binary tree

    +

    Figure 7-4   Perfect binary tree

    + +

    2.   Complete binary tree

    +

    As shown in the Figure 7-5 , a "complete binary tree" has only the bottom level nodes not fully filled, and the bottom level nodes are filled as far left as possible.

    +

    Complete binary tree

    +

    Figure 7-5   Complete binary tree

    + +

    3.   Full binary tree

    +

    As shown in the Figure 7-6 , a "full binary tree" has all nodes except leaf nodes having two children.

    +

    Full binary tree

    +

    Figure 7-6   Full binary tree

    + +

    4.   Balanced binary tree

    +

    As shown in the Figure 7-7 , in a "balanced binary tree," the absolute difference in height between the left and right subtrees of any node does not exceed 1.

    +

    Balanced binary tree

    +

    Figure 7-7   Balanced binary tree

    + +

    7.1.4   Degeneration of binary trees

    +

    The Figure 7-8 shows the ideal and degenerate structures of binary trees. When every level of a binary tree is filled, it reaches the "perfect binary tree"; when all nodes are biased towards one side, the binary tree degenerates into a "linked list".

    +
      +
    • The perfect binary tree is the ideal situation, fully leveraging the "divide and conquer" advantage of binary trees.
      • +
    • A linked list is another extreme, where operations become linear, degrading the time complexity to \(O(n)\).
      • +
    +

    The Best and Worst Structures of Binary Trees

    +

    Figure 7-8   The Best and Worst Structures of Binary Trees

    + +

    As shown in the Table 7-1 , in the best and worst structures, the number of leaf nodes, total number of nodes, and height of the binary tree reach their maximum or minimum values.

    +

    Table 7-1   The Best and Worst Structures of Binary Trees

    + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Perfect binary treeLinked list
    Number of nodes at level \(i\)\(2^{i-1}\)\(1\)
    Number of leaf nodes in a tree with height \(h\)\(2^h\)\(1\)
    Total number of nodes in a tree with height \(h\)\(2^{h+1} - 1\)\(h + 1\)
    Height of a tree with \(n\) total nodes\(\log_2 (n+1) - 1\)\(n - 1\)
    +
    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_tree/binary_tree_traversal.assets/binary_tree_bfs.png b/en/chapter_tree/binary_tree_traversal.assets/binary_tree_bfs.png new file mode 100644 index 0000000000000000000000000000000000000000..2c5326772769447d9610af8db812fd15ef95511e GIT binary patch literal 15450 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree_traversal.assets/preorder_step10.png b/en/chapter_tree/binary_tree_traversal.assets/preorder_step10.png new file mode 100644 index 0000000000000000000000000000000000000000..6f864c7880ce0114e6be7c712a3fec8a2b39c591 GIT binary patch literal 25164 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree_traversal.assets/preorder_step11.png b/en/chapter_tree/binary_tree_traversal.assets/preorder_step11.png new file mode 100644 index 0000000000000000000000000000000000000000..d3026cfe4b203b4a3dfdbf6e166083307eee4810 GIT binary patch literal 26621 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree_traversal.assets/preorder_step4.png b/en/chapter_tree/binary_tree_traversal.assets/preorder_step4.png new file mode 100644 index 0000000000000000000000000000000000000000..2977b827ddc1d5bd663205b5031a4766268eb71f GIT binary patch literal 19197 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree_traversal.assets/preorder_step5.png b/en/chapter_tree/binary_tree_traversal.assets/preorder_step5.png new file mode 100644 index 0000000000000000000000000000000000000000..dc68920e10f69cdf213d6e9aff0d2ffb3c403838 GIT binary patch literal 20436 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree_traversal.assets/preorder_step6.png b/en/chapter_tree/binary_tree_traversal.assets/preorder_step6.png new file mode 100644 index 0000000000000000000000000000000000000000..807c36a0630da818c651aed445c58530687d3f21 GIT binary patch literal 21722 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree_traversal.assets/preorder_step8.png b/en/chapter_tree/binary_tree_traversal.assets/preorder_step8.png new file mode 100644 index 0000000000000000000000000000000000000000..d5d694c74553519062ce42698020c7de5d98ada8 GIT binary patch literal 23670 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 literal 0 HcmV?d00001 diff --git a/en/chapter_tree/binary_tree_traversal.assets/preorder_step9.png b/en/chapter_tree/binary_tree_traversal.assets/preorder_step9.png new file mode 100644 index 0000000000000000000000000000000000000000..afb7495c74ac30f50f8942568254b88ab25ebc08 GIT binary patch literal 24191 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 VlI)6+=Gy + + + + + + + + + + + + + + + + + + + + + + + + + + + 7.2 Binary Tree Traversal - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    7.2   Binary tree traversal

    +

    From the perspective of physical structure, a tree is a data structure based on linked lists, hence its traversal method involves accessing nodes one by one through pointers. However, a tree is a non-linear data structure, which makes traversing a tree more complex than traversing a linked list, requiring the assistance of search algorithms to achieve.

    +

    Common traversal methods for binary trees include level-order traversal, preorder traversal, inorder traversal, and postorder traversal, among others.

    +

    7.2.1   Level-order traversal

    +

    As shown in the Figure 7-9 , "level-order traversal" traverses the binary tree from top to bottom, layer by layer, and accesses nodes in each layer in a left-to-right order.

    +

    Level-order traversal essentially belongs to "breadth-first traversal", also known as "breadth-first search (BFS)", which embodies a "circumferentially outward expanding" layer-by-layer traversal method.

    +

    Level-order traversal of a binary tree

    +

    Figure 7-9   Level-order traversal of a binary tree

    + +

    1.   Code implementation

    +

    Breadth-first traversal is usually implemented with the help of a "queue". The queue follows the "first in, first out" rule, while breadth-first traversal follows the "layer-by-layer progression" rule, the underlying ideas of the two are consistent. The implementation code is as follows:

    +
    +
    +
    +
    binary_tree_bfs.py
    def level_order(root: TreeNode | None) -> list[int]:
+    """层序遍历"""
+    # 初始化队列，加入根节点
+    queue: deque[TreeNode] = deque()
+    queue.append(root)
+    # 初始化一个列表，用于保存遍历序列
+    res = []
+    while queue:
+        node: TreeNode = queue.popleft()  # 队列出队
+        res.append(node.val)  # 保存节点值
+        if node.left is not None:
+            queue.append(node.left)  # 左子节点入队
+        if node.right is not None:
+            queue.append(node.right)  # 右子节点入队
+    return res
+
    +
    +
    +
    binary_tree_bfs.cpp
    /* 层序遍历 */
+vector<int> levelOrder(TreeNode *root) {
+    // 初始化队列，加入根节点
+    queue<TreeNode *> queue;
+    queue.push(root);
+    // 初始化一个列表，用于保存遍历序列
+    vector<int> vec;
+    while (!queue.empty()) {
+        TreeNode *node = queue.front();
+        queue.pop();              // 队列出队
+        vec.push_back(node->val); // 保存节点值
+        if (node->left != nullptr)
+            queue.push(node->left); // 左子节点入队
+        if (node->right != nullptr)
+            queue.push(node->right); // 右子节点入队
+    }
+    return vec;
+}
+
    +
    +
    +
    binary_tree_bfs.java
    /* 层序遍历 */
+List<Integer> levelOrder(TreeNode root) {
+    // 初始化队列，加入根节点
+    Queue<TreeNode> queue = new LinkedList<>();
+    queue.add(root);
+    // 初始化一个列表，用于保存遍历序列
+    List<Integer> list = new ArrayList<>();
+    while (!queue.isEmpty()) {
+        TreeNode node = queue.poll(); // 队列出队
+        list.add(node.val);           // 保存节点值
+        if (node.left != null)
+            queue.offer(node.left);   // 左子节点入队
+        if (node.right != null)
+            queue.offer(node.right);  // 右子节点入队
+    }
+    return list;
+}
+
    +
    +
    +
    binary_tree_bfs.cs
    /* 层序遍历 */
+List<int> LevelOrder(TreeNode root) {
+    // 初始化队列，加入根节点
+    Queue<TreeNode> queue = new();
+    queue.Enqueue(root);
+    // 初始化一个列表，用于保存遍历序列
+    List<int> list = [];
+    while (queue.Count != 0) {
+        TreeNode node = queue.Dequeue(); // 队列出队
+        list.Add(node.val!.Value);       // 保存节点值
+        if (node.left != null)
+            queue.Enqueue(node.left);    // 左子节点入队
+        if (node.right != null)
+            queue.Enqueue(node.right);   // 右子节点入队
+    }
+    return list;
+}
+
    +
    +
    +
    binary_tree_bfs.go
    /* 层序遍历 */
+func levelOrder(root *TreeNode) []any {
+    // 初始化队列，加入根节点
+    queue := list.New()
+    queue.PushBack(root)
+    // 初始化一个切片，用于保存遍历序列
+    nums := make([]any, 0)
+    for queue.Len() > 0 {
+        // 队列出队
+        node := queue.Remove(queue.Front()).(*TreeNode)
+        // 保存节点值
+        nums = append(nums, node.Val)
+        if node.Left != nil {
+            // 左子节点入队
+            queue.PushBack(node.Left)
+        }
+        if node.Right != nil {
+            // 右子节点入队
+            queue.PushBack(node.Right)
+        }
+    }
+    return nums
+}
+
    +
    +
    +
    binary_tree_bfs.swift
    /* 层序遍历 */
+func levelOrder(root: TreeNode) -> [Int] {
+    // 初始化队列，加入根节点
+    var queue: [TreeNode] = [root]
+    // 初始化一个列表，用于保存遍历序列
+    var list: [Int] = []
+    while !queue.isEmpty {
+        let node = queue.removeFirst() // 队列出队
+        list.append(node.val) // 保存节点值
+        if let left = node.left {
+            queue.append(left) // 左子节点入队
+        }
+        if let right = node.right {
+            queue.append(right) // 右子节点入队
+        }
+    }
+    return list
+}
+
    +
    +
    +
    binary_tree_bfs.js
    /* 层序遍历 */
+function levelOrder(root) {
+    // 初始化队列，加入根节点
+    const queue = [root];
+    // 初始化一个列表，用于保存遍历序列
+    const list = [];
+    while (queue.length) {
+        let node = queue.shift(); // 队列出队
+        list.push(node.val); // 保存节点值
+        if (node.left) queue.push(node.left); // 左子节点入队
+        if (node.right) queue.push(node.right); // 右子节点入队
+    }
+    return list;
+}
+
    +
    +
    +
    binary_tree_bfs.ts
    /* 层序遍历 */
+function levelOrder(root: TreeNode | null): number[] {
+    // 初始化队列，加入根节点
+    const queue = [root];
+    // 初始化一个列表，用于保存遍历序列
+    const list: number[] = [];
+    while (queue.length) {
+        let node = queue.shift() as TreeNode; // 队列出队
+        list.push(node.val); // 保存节点值
+        if (node.left) {
+            queue.push(node.left); // 左子节点入队
+        }
+        if (node.right) {
+            queue.push(node.right); // 右子节点入队
+        }
+    }
+    return list;
+}
+
    +
    +
    +
    binary_tree_bfs.dart
    /* 层序遍历 */
+List<int> levelOrder(TreeNode? root) {
+  // 初始化队列，加入根节点
+  Queue<TreeNode?> queue = Queue();
+  queue.add(root);
+  // 初始化一个列表，用于保存遍历序列
+  List<int> res = [];
+  while (queue.isNotEmpty) {
+    TreeNode? node = queue.removeFirst(); // 队列出队
+    res.add(node!.val); // 保存节点值
+    if (node.left != null) queue.add(node.left); // 左子节点入队
+    if (node.right != null) queue.add(node.right); // 右子节点入队
+  }
+  return res;
+}
+
    +
    +
    +
    binary_tree_bfs.rs
    /* 层序遍历 */
+fn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {
+    // 初始化队列，加入根节点
+    let mut que = VecDeque::new();
+    que.push_back(Rc::clone(&root));
+    // 初始化一个列表，用于保存遍历序列
+    let mut vec = Vec::new();
+
+    while let Some(node) = que.pop_front() {
+        // 队列出队
+        vec.push(node.borrow().val); // 保存节点值
+        if let Some(left) = node.borrow().left.as_ref() {
+            que.push_back(Rc::clone(left)); // 左子节点入队
+        }
+        if let Some(right) = node.borrow().right.as_ref() {
+            que.push_back(Rc::clone(right)); // 右子节点入队
+        };
+    }
+    vec
+}
+
    +
    +
    +
    binary_tree_bfs.c
    /* 层序遍历 */
+int *levelOrder(TreeNode *root, int *size) {
+    /* 辅助队列 */
+    int front, rear;
+    int index, *arr;
+    TreeNode *node;
+    TreeNode **queue;
+
+    /* 辅助队列 */
+    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);
+    // 队列指针
+    front = 0, rear = 0;
+    // 加入根节点
+    queue[rear++] = root;
+    // 初始化一个列表，用于保存遍历序列
+    /* 辅助数组 */
+    arr = (int *)malloc(sizeof(int) * MAX_SIZE);
+    // 数组指针
+    index = 0;
+    while (front < rear) {
+        // 队列出队
+        node = queue[front++];
+        // 保存节点值
+        arr[index++] = node->val;
+        if (node->left != NULL) {
+            // 左子节点入队
+            queue[rear++] = node->left;
+        }
+        if (node->right != NULL) {
+            // 右子节点入队
+            queue[rear++] = node->right;
+        }
+    }
+    // 更新数组长度的值
+    *size = index;
+    arr = realloc(arr, sizeof(int) * (*size));
+
+    // 释放辅助数组空间
+    free(queue);
+    return arr;
+}
+
    +
    +
    +
    binary_tree_bfs.kt
    /* 层序遍历 */
+fun levelOrder(root: TreeNode?): MutableList<Int> {
+    // 初始化队列，加入根节点
+    val queue = LinkedList<TreeNode?>()
+    queue.add(root)
+    // 初始化一个列表，用于保存遍历序列
+    val list = ArrayList<Int>()
+    while (!queue.isEmpty()) {
+        val node = queue.poll() // 队列出队
+        list.add(node?.value!!) // 保存节点值
+        if (node.left != null) queue.offer(node.left) // 左子节点入队
+
+        if (node.right != null) queue.offer(node.right) // 右子节点入队
+    }
+    return list
+}
+
    +
    +
    +
    binary_tree_bfs.rb
    [class]{}-[func]{level_order}
+
    +
    +
    +
    binary_tree_bfs.zig
    // 层序遍历
+fn levelOrder(comptime T: type, mem_allocator: std.mem.Allocator, root: *inc.TreeNode(T)) !std.ArrayList(T) {
+    // 初始化队列，加入根节点
+    const L = std.TailQueue(*inc.TreeNode(T));
+    var queue = L{};
+    var root_node = try mem_allocator.create(L.Node);
+    root_node.data = root;
+    queue.append(root_node); 
+    // 初始化一个列表，用于保存遍历序列
+    var list = std.ArrayList(T).init(std.heap.page_allocator);
+    while (queue.len > 0) {
+        var queue_node = queue.popFirst().?;    // 队列出队
+        var node = queue_node.data;
+        try list.append(node.val);              // 保存节点值
+        if (node.left != null) {
+            var tmp_node = try mem_allocator.create(L.Node);
+            tmp_node.data = node.left.?;
+            queue.append(tmp_node);             // 左子节点入队
+        }
+        if (node.right != null) {
+            var tmp_node = try mem_allocator.create(L.Node);
+            tmp_node.data = node.right.?;
+            queue.append(tmp_node);             // 右子节点入队
+        }        
+    }
+    return list;
+}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +

    2.   Complexity analysis

    +
      +
    • Time complexity is \(O(n)\): All nodes are visited once, using \(O(n)\) time, where \(n\) is the number of nodes.
      • +
    • Space complexity is \(O(n)\): In the worst case, i.e., a full binary tree, before traversing to the lowest level, the queue can contain at most \((n + 1) / 2\) nodes at the same time, occupying \(O(n)\) space.
      • +
    +

    7.2.2   Preorder, inorder, and postorder traversal

    +

    Correspondingly, preorder, inorder, and postorder traversal all belong to "depth-first traversal", also known as "depth-first search (DFS)", which embodies a "proceed to the end first, then backtrack and continue" traversal method.

    +

    The Figure 7-10 shows the working principle of performing a depth-first traversal on a binary tree. Depth-first traversal is like walking around the perimeter of the entire binary tree, encountering three positions at each node, corresponding to preorder traversal, inorder traversal, and postorder traversal.

    +

    Preorder, inorder, and postorder traversal of a binary search tree

    +

    Figure 7-10   Preorder, inorder, and postorder traversal of a binary search tree

    + +

    1.   Code implementation

    +

    Depth-first search is usually implemented based on recursion:

    +
    +
    +
    +
    binary_tree_dfs.py
    def pre_order(root: TreeNode | None):
+    """前序遍历"""
+    if root is None:
+        return
+    # 访问优先级：根节点 -> 左子树 -> 右子树
+    res.append(root.val)
+    pre_order(root=root.left)
+    pre_order(root=root.right)
+
+def in_order(root: TreeNode | None):
+    """中序遍历"""
+    if root is None:
+        return
+    # 访问优先级：左子树 -> 根节点 -> 右子树
+    in_order(root=root.left)
+    res.append(root.val)
+    in_order(root=root.right)
+
+def post_order(root: TreeNode | None):
+    """后序遍历"""
+    if root is None:
+        return
+    # 访问优先级：左子树 -> 右子树 -> 根节点
+    post_order(root=root.left)
+    post_order(root=root.right)
+    res.append(root.val)
+
    +
    +
    +
    binary_tree_dfs.cpp
    /* 前序遍历 */
+void preOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    vec.push_back(root->val);
+    preOrder(root->left);
+    preOrder(root->right);
+}
+
+/* 中序遍历 */
+void inOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    inOrder(root->left);
+    vec.push_back(root->val);
+    inOrder(root->right);
+}
+
+/* 后序遍历 */
+void postOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    postOrder(root->left);
+    postOrder(root->right);
+    vec.push_back(root->val);
+}
+
    +
    +
    +
    binary_tree_dfs.java
    /* 前序遍历 */
+void preOrder(TreeNode root) {
+    if (root == null)
+        return;
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    list.add(root.val);
+    preOrder(root.left);
+    preOrder(root.right);
+}
+
+/* 中序遍历 */
+void inOrder(TreeNode root) {
+    if (root == null)
+        return;
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    inOrder(root.left);
+    list.add(root.val);
+    inOrder(root.right);
+}
+
+/* 后序遍历 */
+void postOrder(TreeNode root) {
+    if (root == null)
+        return;
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    postOrder(root.left);
+    postOrder(root.right);
+    list.add(root.val);
+}
+
    +
    +
    +
    binary_tree_dfs.cs
    /* 前序遍历 */
+void PreOrder(TreeNode? root) {
+    if (root == null) return;
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    list.Add(root.val!.Value);
+    PreOrder(root.left);
+    PreOrder(root.right);
+}
+
+/* 中序遍历 */
+void InOrder(TreeNode? root) {
+    if (root == null) return;
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    InOrder(root.left);
+    list.Add(root.val!.Value);
+    InOrder(root.right);
+}
+
+/* 后序遍历 */
+void PostOrder(TreeNode? root) {
+    if (root == null) return;
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    PostOrder(root.left);
+    PostOrder(root.right);
+    list.Add(root.val!.Value);
+}
+
    +
    +
    +
    binary_tree_dfs.go
    /* 前序遍历 */
+func preOrder(node *TreeNode) {
+    if node == nil {
+        return
+    }
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    nums = append(nums, node.Val)
+    preOrder(node.Left)
+    preOrder(node.Right)
+}
+
+/* 中序遍历 */
+func inOrder(node *TreeNode) {
+    if node == nil {
+        return
+    }
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    inOrder(node.Left)
+    nums = append(nums, node.Val)
+    inOrder(node.Right)
+}
+
+/* 后序遍历 */
+func postOrder(node *TreeNode) {
+    if node == nil {
+        return
+    }
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    postOrder(node.Left)
+    postOrder(node.Right)
+    nums = append(nums, node.Val)
+}
+
    +
    +
    +
    binary_tree_dfs.swift
    /* 前序遍历 */
+func preOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    list.append(root.val)
+    preOrder(root: root.left)
+    preOrder(root: root.right)
+}
+
+/* 中序遍历 */
+func inOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    inOrder(root: root.left)
+    list.append(root.val)
+    inOrder(root: root.right)
+}
+
+/* 后序遍历 */
+func postOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    postOrder(root: root.left)
+    postOrder(root: root.right)
+    list.append(root.val)
+}
+
    +
    +
    +
    binary_tree_dfs.js
    /* 前序遍历 */
+function preOrder(root) {
+    if (root === null) return;
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    list.push(root.val);
+    preOrder(root.left);
+    preOrder(root.right);
+}
+
+/* 中序遍历 */
+function inOrder(root) {
+    if (root === null) return;
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    inOrder(root.left);
+    list.push(root.val);
+    inOrder(root.right);
+}
+
+/* 后序遍历 */
+function postOrder(root) {
+    if (root === null) return;
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    postOrder(root.left);
+    postOrder(root.right);
+    list.push(root.val);
+}
+
    +
    +
    +
    binary_tree_dfs.ts
    /* 前序遍历 */
+function preOrder(root: TreeNode | null): void {
+    if (root === null) {
+        return;
+    }
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    list.push(root.val);
+    preOrder(root.left);
+    preOrder(root.right);
+}
+
+/* 中序遍历 */
+function inOrder(root: TreeNode | null): void {
+    if (root === null) {
+        return;
+    }
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    inOrder(root.left);
+    list.push(root.val);
+    inOrder(root.right);
+}
+
+/* 后序遍历 */
+function postOrder(root: TreeNode | null): void {
+    if (root === null) {
+        return;
+    }
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    postOrder(root.left);
+    postOrder(root.right);
+    list.push(root.val);
+}
+
    +
    +
    +
    binary_tree_dfs.dart
    /* 前序遍历 */
+void preOrder(TreeNode? node) {
+  if (node == null) return;
+  // 访问优先级：根节点 -> 左子树 -> 右子树
+  list.add(node.val);
+  preOrder(node.left);
+  preOrder(node.right);
+}
+
+/* 中序遍历 */
+void inOrder(TreeNode? node) {
+  if (node == null) return;
+  // 访问优先级：左子树 -> 根节点 -> 右子树
+  inOrder(node.left);
+  list.add(node.val);
+  inOrder(node.right);
+}
+
+/* 后序遍历 */
+void postOrder(TreeNode? node) {
+  if (node == null) return;
+  // 访问优先级：左子树 -> 右子树 -> 根节点
+  postOrder(node.left);
+  postOrder(node.right);
+  list.add(node.val);
+}
+
    +
    +
    +
    binary_tree_dfs.rs
    /* 前序遍历 */
+fn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    if let Some(node) = root {
+        // 访问优先级：根节点 -> 左子树 -> 右子树
+        result.push(node.borrow().val);
+        result.append(&mut pre_order(node.borrow().left.as_ref()));
+        result.append(&mut pre_order(node.borrow().right.as_ref()));
+    }
+    result
+}
+
+/* 中序遍历 */
+fn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    if let Some(node) = root {
+        // 访问优先级：左子树 -> 根节点 -> 右子树
+        result.append(&mut in_order(node.borrow().left.as_ref()));
+        result.push(node.borrow().val);
+        result.append(&mut in_order(node.borrow().right.as_ref()));
+    }
+    result
+}
+
+/* 后序遍历 */
+fn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut result = vec![];
+
+    if let Some(node) = root {
+        // 访问优先级：左子树 -> 右子树 -> 根节点
+        result.append(&mut post_order(node.borrow().left.as_ref()));
+        result.append(&mut post_order(node.borrow().right.as_ref()));
+        result.push(node.borrow().val);
+    }
+    result
+}
+
    +
    +
    +
    binary_tree_dfs.c
    /* 前序遍历 */
+void preOrder(TreeNode *root, int *size) {
+    if (root == NULL)
+        return;
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    arr[(*size)++] = root->val;
+    preOrder(root->left, size);
+    preOrder(root->right, size);
+}
+
+/* 中序遍历 */
+void inOrder(TreeNode *root, int *size) {
+    if (root == NULL)
+        return;
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    inOrder(root->left, size);
+    arr[(*size)++] = root->val;
+    inOrder(root->right, size);
+}
+
+/* 后序遍历 */
+void postOrder(TreeNode *root, int *size) {
+    if (root == NULL)
+        return;
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    postOrder(root->left, size);
+    postOrder(root->right, size);
+    arr[(*size)++] = root->val;
+}
+
    +
    +
    +
    binary_tree_dfs.kt
    /* 前序遍历 */
+fun preOrder(root: TreeNode?) {
+    if (root == null) return
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    list.add(root.value)
+    preOrder(root.left)
+    preOrder(root.right)
+}
+
+/* 中序遍历 */
+fun inOrder(root: TreeNode?) {
+    if (root == null) return
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    inOrder(root.left)
+    list.add(root.value)
+    inOrder(root.right)
+}
+
+/* 后序遍历 */
+fun postOrder(root: TreeNode?) {
+    if (root == null) return
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    postOrder(root.left)
+    postOrder(root.right)
+    list.add(root.value)
+}
+
    +
    +
    +
    binary_tree_dfs.rb
    [class]{}-[func]{pre_order}
+
+[class]{}-[func]{in_order}
+
+[class]{}-[func]{post_order}
+
    +
    +
    +
    binary_tree_dfs.zig
    // 前序遍历
+fn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+    if (root == null) return;
+    // 访问优先级：根节点 -> 左子树 -> 右子树
+    try list.append(root.?.val);
+    try preOrder(T, root.?.left);
+    try preOrder(T, root.?.right);
+}
+
+// 中序遍历
+fn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+    if (root == null) return;
+    // 访问优先级：左子树 -> 根节点 -> 右子树
+    try inOrder(T, root.?.left);
+    try list.append(root.?.val);
+    try inOrder(T, root.?.right);
+}
+
+// 后序遍历
+fn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {
+    if (root == null) return;
+    // 访问优先级：左子树 -> 右子树 -> 根节点
+    try postOrder(T, root.?.left);
+    try postOrder(T, root.?.right);
+    try list.append(root.?.val);
+}
+
    +
    +
    +
    +
    +Code Visualization +

    +

    +
    +
    +

    Tip

    +

    Depth-first search can also be implemented based on iteration, interested readers can study this on their own.

    +
    +

    The Figure 7-11 shows the recursive process of preorder traversal of a binary tree, which can be divided into two opposite parts: "recursion" and "return".

    +
      +
    1. "Recursion" means starting a new method, the program accesses the next node in this process.
      2. +
    2. "Return" means the function returns, indicating the current node has been fully accessed.
      3. +
    +
    +
    +
    +

    The recursive process of preorder traversal

    +
    +
    +

    preorder_step2

    +
    +
    +

    preorder_step3

    +
    +
    +

    preorder_step4

    +
    +
    +

    preorder_step5

    +
    +
    +

    preorder_step6

    +
    +
    +

    preorder_step7

    +
    +
    +

    preorder_step8

    +
    +
    +

    preorder_step9

    +
    +
    +

    preorder_step10

    +
    +
    +

    preorder_step11

    +
    +
    +
    +

    Figure 7-11   The recursive process of preorder traversal

    + +

    2.   Complexity analysis

    +
      +
    • Time complexity is \(O(n)\): All nodes are visited once, using \(O(n)\) time.
      • +
    • Space complexity is \(O(n)\): In the worst case, i.e., the tree degrades into a linked list, the recursion depth reaches \(n\), the system occupies \(O(n)\) stack frame space.
      • +
    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_tree/index.html b/en/chapter_tree/index.html new file mode 100644 index 000000000..44e27b579 --- /dev/null +++ b/en/chapter_tree/index.html @@ -0,0 +1,2275 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Chapter 7.   Tree - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    Chapter 7.   Tree

    +

    Tree

    +
    +

    Abstract

    +

    The towering tree, full of vitality with its roots deep and leaves lush, branches spreading wide.

    +

    It vividly demonstrates the form of data divide-and-conquer.

    +
    +

    Chapter Contents

    + + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/chapter_tree/summary/index.html b/en/chapter_tree/summary/index.html new file mode 100644 index 000000000..76bec989b --- /dev/null +++ b/en/chapter_tree/summary/index.html @@ -0,0 +1,2363 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 7.6 Summary - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + +
    + + + + + + +
    + + +
    + +
    + + + + + + +
    +
    + + + +
    +
    +
    + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + +

    7.6   Summary

    +

    1.   Key review

    +
      +
    • A binary tree is a non-linear data structure that reflects the "divide and conquer" logic of splitting one into two. Each binary tree node contains a value and two pointers, which point to its left and right child nodes, respectively.
      • +
    • For a node in a binary tree, the tree formed by its left (right) child node and all nodes under it is called the node's left (right) subtree.
      • +
    • Related terminology of binary trees includes root node, leaf node, level, degree, edge, height, and depth, among others.
      • +
    • The operations of initializing a binary tree, inserting nodes, and removing nodes are similar to those of linked list operations.
      • +
    • Common types of binary trees include perfect binary trees, complete binary trees, full binary trees, and balanced binary trees. The perfect binary tree represents the ideal state, while the linked list is the worst state after degradation.
      • +
    • A binary tree can be represented using an array by arranging the node values and empty slots in a level-order traversal sequence and implementing pointers based on the index mapping relationship between parent nodes and child nodes.
      • +
    • The level-order traversal of a binary tree is a breadth-first search method, which reflects a layer-by-layer traversal manner of "expanding circle by circle." It is usually implemented using a queue.
      • +
    • Pre-order, in-order, and post-order traversals are all depth-first search methods, reflecting the traversal manner of "going to the end first, then backtracking to continue." They are usually implemented using recursion.
      • +
    • A binary search tree is an efficient data structure for element searching, with the time complexity of search, insert, and remove operations all being \(O(\log n)\). When a binary search tree degrades into a linked list, these time complexities deteriorate to \(O(n)\).
      • +
    • An AVL tree, also known as a balanced binary search tree, ensures that the tree remains balanced after continuous node insertions and removals through rotation operations.
      • +
    • Rotation operations in an AVL tree include right rotation, left rotation, right-then-left rotation, and left-then-right rotation. After inserting or removing nodes, an AVL tree performs rotation operations from bottom to top to rebalance the tree.
      • +
    +

    2.   Q & A

    +

    Q: For a binary tree with only one node, are both the height of the tree and the depth of the root node \(0\)?

    +

    Yes, because height and depth are typically defined as "the number of edges passed."

    +

    Q: The insertion and removal in a binary tree are generally completed by a set of operations. What does "a set of operations" refer to here? Can it be understood as the release of resources of the child nodes?

    +

    Taking the binary search tree as an example, the operation of removing a node needs to be handled in three different scenarios, each requiring multiple steps of node operations.

    +

    Q: Why are there three sequences: pre-order, in-order, and post-order for DFS traversal of a binary tree, and what are their uses?

    +

    Similar to sequential and reverse traversal of arrays, pre-order, in-order, and post-order traversals are three methods of traversing a binary tree, allowing us to obtain a traversal result in a specific order. For example, in a binary search tree, since the node sizes satisfy left child node value < root node value < right child node value, we can obtain an ordered node sequence by traversing the tree in the "left → root → right" priority.

    +

    Q: In a right rotation operation that deals with the relationship between the imbalance nodes node, child, grand_child, isn't the connection between node and its parent node and the original link of node lost after the right rotation?

    +

    We need to view this problem from a recursive perspective. The right_rotate(root) operation passes the root node of the subtree and eventually returns the root node of the rotated subtree with return child. The connection between the subtree's root node and its parent node is established after this function returns, which is outside the scope of the right rotation operation's maintenance.

    +

    Q: In C++, functions are divided into private and public sections. What considerations are there for this? Why are the height() function and the updateHeight() function placed in public and private, respectively?

    +

    It depends on the scope of the method's use. If a method is only used within the class, then it is designed to be private. For example, it makes no sense for users to call updateHeight() on their own, as it is just a step in the insertion or removal operations. However, height() is for accessing node height, similar to vector.size(), thus it is set to public for use.

    +

    Q: How do you build a binary search tree from a set of input data? Is the choice of root node very important?

    +

    Yes, the method for building the tree is provided in the build_tree() method in the binary search tree code. As for the choice of the root node, we usually sort the input data and then select the middle element as the root node, recursively building the left and right subtrees. This approach maximizes the balance of the tree.

    +

    Q: In Java, do you always have to use the equals() method for string comparison?

    +

    In Java, for primitive data types, == is used to compare whether the values of two variables are equal. For reference types, the working principles of the two symbols are different.

    +
      +
    • ==: Used to compare whether two variables point to the same object, i.e., whether their positions in memory are the same.
      • +
    • equals(): Used to compare whether the values of two objects are equal.
      • +
    +

    Therefore, to compare values, we should use equals(). However, strings initialized with String a = "hi"; String b = "hi"; are stored in the string constant pool and point to the same object, so a == b can also be used to compare the contents of two strings.

    +

    Q: Before reaching the bottom level, is the number of nodes in the queue \(2^h\) in breadth-first traversal?

    +

    Yes, for example, a full binary tree with height \(h = 2\) has a total of \(n = 7\) nodes, then the bottom level has \(4 = 2^h = (n + 1) / 2\) nodes.

    + + + + + + + + + + + + + + + + + + + +
    Feel free to drop your insights, questions or suggestions
    + + + + + + + +
    +
    + + + + + +
    + + + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/index.html b/en/index.html index 891a0b8f7..40a1ddaa4 100644 --- a/en/index.html +++ b/en/index.html @@ -1404,6 +1404,514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 7. Tree + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 8. Heap + + + + + + + + +
    + + + +
    • + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
  • + + + + + + + + +
    + + + + + + + Chapter 9. Graph + + + + + + + + +
    + + + +
    • + + + diff --git a/en/search/search_index.json b/en/search/search_index.json index d85fa516b..9c5d23c56 100644 --- a/en/search/search_index.json +++ b/en/search/search_index.json @@ -1 +1 @@ -{"config":{"lang":["en"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"]},"docs":[{"location":"","title":"Home","text":"Hello Algo

    Data Structures and Algorithms Crash Course with Animated Illustrations and Off-the-Shelf Code

    Dive In Clone Repo Get PDF

    The English edition is brewing...

    Feel free to engage in Chinese-to-English translation and pull request review! For guidelines, please see #914.

    Quote

    \"An easy-to-understand book on data structures and algorithms, which guides readers to learn by minds-on and hands-on. Strongly recommended for algorithm beginners!\"

    \u2014\u2014 Junhui Deng, Professor of Computer Science, Tsinghua University

    Quote

    \"If I had 'Hello Algo' when I was learning data structures and algorithms, it would have been 10 times easier!\"

    \u2014\u2014 Mu Li, Senior Principal Scientist, Amazon

    Animated illustrations

    Easy to understandSmooth learning curve

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

    Off-the-Shelf Code

    Multi programming languagesRun with one click

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

    Learning Together

    Discussion and questions welcomeReaders progress together

    \"Learning by teaching.\"

    Preface

    Two years ago, I shared the \"Sword Offer\" series of problem solutions on LeetCode, which received much love and support from many students. During my interactions with readers, the most common question I encountered was \"How to get started with algorithms.\" Gradually, I developed a deep interest in this question.

    Blindly solving problems seems to be the most popular method, being simple, direct, and effective. However, problem-solving is like playing a \"Minesweeper\" game, where students with strong self-learning abilities can successfully clear the mines one by one, but those with insufficient foundations may end up bruised from explosions, retreating step by step in frustration. Thoroughly reading textbooks is also common, but for students aiming for job applications, the energy consumed by graduation, resume submissions, and preparing for written tests and interviews makes tackling thick books a daunting challenge.

    If you are facing similar troubles, then you are lucky to have found this book. This book is my answer to this question, not necessarily the best solution, but at least an active attempt. Although this book won't directly land you an Offer, it will guide you through the \"knowledge map\" of data structures and algorithms, help you understand the shape, size, and distribution of different \"mines,\" and equip you with various \"demining methods.\" With these skills, I believe you can more comfortably solve problems and read literature, gradually building a complete knowledge system.

    I deeply agree with Professor Feynman's saying: \"Knowledge isn't free. You have to pay attention.\" In this sense, this book is not entirely \"free.\" To not disappoint the precious \"attention\" you pay to this book, I will do my utmost, investing the greatest \"attention\" to complete the creation of this book.

    Author

    Yudong Jin(krahets), Senior Algorithm Engineer in a top tech company, Master's degree from Shanghai Jiao Tong University. The highest-read blogger across the entire LeetCode, his published \"Illustration of Algorithm Data Structures\" has been subscribed to by over 300k.

    Contribution

    This book is continuously improved with the joint efforts of many contributors from the open-source community. Thanks to each writer who invested their time and energy, listed in the order generated by GitHub:

    The code review work for this book was completed by codingonion, Gonglja, gvenusleo, hpstory, justin\u2010tse, krahets, night-cruise, nuomi1, and Reanon (listed in alphabetical order). Thanks to them for their time and effort, ensuring the standardization and uniformity of the code in various languages.

    codingonionRust, Zig GongljaC, C++ gvenusleoDart hpstoryC# justin-tseJS, TS krahetsJava, Python night-cruiseRust nuomi1Swift ReanonGo, C"},{"location":"chapter_array_and_linkedlist/","title":"Chapter 4. \u00a0 Arrays and Linked Lists","text":"

    Abstract

    The world of data structures resembles a sturdy brick wall.

    In arrays, envision bricks snugly aligned, each resting seamlessly beside the next, creating a unified formation. Meanwhile, in linked lists, these bricks disperse freely, embraced by vines gracefully knitting connections between them.

    "},{"location":"chapter_array_and_linkedlist/#chapter-contents","title":"Chapter Contents","text":"
    • 4.1 \u00a0 Array
    • 4.2 \u00a0 Linked List
    • 4.3 \u00a0 List
    • 4.4 \u00a0 Memory and Cache
    • 4.5 \u00a0 Summary
    "},{"location":"chapter_array_and_linkedlist/array/","title":"4.1 \u00a0 Arrays","text":"

    An \"array\" is a linear data structure that operates as a lineup of similar items, stored together in a computer's memory in contiguous spaces. It's like a sequence that maintains organized storage. Each item in this lineup has its unique 'spot' known as an \"index\". Please refer to the Figure 4-1 to observe how arrays work and grasp these key terms.

    Figure 4-1 \u00a0 Array Definition and Storage Method

    "},{"location":"chapter_array_and_linkedlist/array/#411-common-operations-on-arrays","title":"4.1.1 \u00a0 Common Operations on Arrays","text":""},{"location":"chapter_array_and_linkedlist/array/#1-initializing-arrays","title":"1. \u00a0 Initializing Arrays","text":"

    Arrays can be initialized in two ways depending on the needs: either without initial values or with specified initial values. When initial values are not specified, most programming languages will set the array elements to \\(0\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig array.py
    # Initialize array\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n
    array.cpp
    /* Initialize array */\n// Stored on stack\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// Stored on heap (manual memory release needed)\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n
    array.java
    /* Initialize array */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n
    array.cs
    /* Initialize array */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n
    array.go
    /* Initialize array */\nvar arr [5]int\n// In Go, specifying the length ([5]int) denotes an array, while not specifying it ([]int) denotes a slice.\n// Since Go's arrays are designed to have compile-time fixed length, only constants can be used to specify the length.\n// For convenience in implementing the extend() method, the Slice will be considered as an Array here.\nnums := []int{1, 3, 2, 5, 4}\n
    array.swift
    /* Initialize array */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n
    array.js
    /* Initialize array */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n
    array.ts
    /* Initialize array */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n
    array.dart
    /* Initialize array */\nList<int> arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList<int> nums = [1, 3, 2, 5, 4];\n
    array.rs
    /* Initialize array */\nlet arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]\nlet nums: Vec<i32> = vec![1, 3, 2, 5, 4];\n
    array.c
    /* Initialize array */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n
    array.kt
    \n
    array.zig
    // Initialize array\nvar arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }\nvar nums = [_]i32{ 1, 3, 2, 5, 4 };\n
    "},{"location":"chapter_array_and_linkedlist/array/#2-accessing-elements","title":"2. \u00a0 Accessing Elements","text":"

    Elements in an array are stored in contiguous memory spaces, making it simpler to compute each element's memory address. The formula shown in the Figure below aids in determining an element's memory address, utilizing the array's memory address (specifically, the first element's address) and the element's index. This computation streamlines direct access to the desired element.

    Figure 4-2 \u00a0 Memory Address Calculation for Array Elements

    As observed in the above illustration, array indexing conventionally begins at \\(0\\). While this might appear counterintuitive, considering counting usually starts at \\(1\\), within the address calculation formula, an index is essentially an offset from the memory address. For the first element's address, this offset is \\(0\\), validating its index as \\(0\\).

    Accessing elements in an array is highly efficient, allowing us to randomly access any element in \\(O(1)\\) time.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    random_index = random.randint(0, len(nums) - 1)\n    # \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    random_num = nums[random_index]\n    return random_num\n
    array.cpp
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n    // \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = rand() % size;\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.java
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int[] nums) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.cs
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // \u5728\u533a\u95f4 [0, nums.Length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = random.Next(nums.Length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.go
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunc randomAccess(nums []int) (randomNum int) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    randomIndex := rand.Intn(len(nums))\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    randomNum = nums[randomIndex]\n    return\n}\n
    array.swift
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunc randomAccess(nums: [Int]) -> Int {\n    // \u5728\u533a\u95f4 [0, nums.count) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    let randomIndex = nums.indices.randomElement()!\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n
    array.js
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunction randomAccess(nums) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    const random_index = Math.floor(Math.random() * nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    const random_num = nums[random_index];\n    return random_num;\n}\n
    array.ts
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunction randomAccess(nums: number[]): number {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    const random_index = Math.floor(Math.random() * nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    const random_num = nums[random_index];\n    return random_num;\n}\n
    array.dart
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(List<int> nums) {\n  // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n  int randomIndex = Random().nextInt(nums.length);\n  // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n
    array.rs
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfn random_access(nums: &[i32]) -> i32 {\n    // \u5728\u533a\u95f4 [0, nums.len()) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    let random_num = nums[random_index];\n    random_num\n}\n
    array.c
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n    // \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = rand() % size;\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.kt
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfun randomAccess(nums: IntArray): Int {\n    // \u5728\u533a\u95f4 [0, nums.size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n
    array.rb
    ### \u968f\u673a\u8bbf\u95ee\u5143\u7d20 ###\ndef random_access(nums)\n  # \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n  random_index = Random.rand 0...(nums.length - 1)\n\n  # \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n  nums[random_index]\nend\n
    array.zig
    // \u968f\u673a\u8bbf\u95ee\u5143\u7d20\nfn randomAccess(nums: []i32) i32 {\n    // \u5728\u533a\u95f4 [0, nums.len) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6574\u6570\n    var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    var randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#3-inserting-elements","title":"3. \u00a0 Inserting Elements","text":"

    Array elements are tightly packed in memory, with no space available to accommodate additional data between them. Illustrated in Figure below, inserting an element in the middle of an array requires shifting all subsequent elements back by one position to create room for the new element.

    Figure 4-3 \u00a0 Array Element Insertion Example

    It's important to note that due to the fixed length of an array, inserting an element will unavoidably result in the loss of the last element in the array. Solutions to address this issue will be explored in the \"List\" chapter.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def insert(nums: list[int], num: int, index: int):\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\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num\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\n    for (int i = size - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    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\n    for (int i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (int i = nums.Length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\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\n    for i := len(nums) - 1; i > index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (let i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (let i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 _num */\nvoid insert(List<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\n  for (var i = nums.length - 1; i > index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // \u5c06 _num \u8d4b\u7ed9 index \u5904\u5143\u7d20\n  nums[index] = _num;\n}\n
    array.rs
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfn insert(nums: &mut Vec<i32>, num: i32, index: usize) {\n    // \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (int i = size - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    array.kt
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num\n}\n
    array.rb
    ### \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num ###\ndef insert(nums, num, index)\n  # \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n  nums[index] = num\nend\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\n    var i = nums.len - 1;\n    while (i > index) : (i -= 1) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#4-deleting-elements","title":"4. \u00a0 Deleting Elements","text":"

    Similarly, as depicted in the Figure 4-4 , to delete an element at index \\(i\\), all elements following index \\(i\\) must be moved forward by one position.

    Figure 4-4 \u00a0 Array Element Deletion Example

    Please note that after deletion, the former last element becomes \"meaningless,\" hence requiring no specific modification.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def remove(nums: list[int], index: int):\n    \"\"\"\u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20\"\"\"\n    # \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n
    array.cpp
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.java
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.cs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.go
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for i := index; i < len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n
    array.swift
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfunc remove(nums: inout [Int], index: Int) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n
    array.js
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfunction remove(nums, index) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (let i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.ts
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (let i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.dart
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nvoid remove(List<int> nums, int index) {\n  // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n  for (var i = index; i < nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n
    array.rs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfn remove(nums: &mut Vec<i32>, index: usize) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.c
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.kt
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfun remove(nums: IntArray, index: Int) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (i in index..<nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n
    array.rb
    ### \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 ###\ndef remove(nums, index)\n  # \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n  for i in index...nums.length\n    nums[i] = nums[i + 1] || 0\n  end\nend\n
    array.zig
    // \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    var i = index;\n    while (i < nums.len - 1) : (i += 1) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    Code Visualization

    Full Screen >

    In summary, the insertion and deletion operations in arrays present the following disadvantages:

    • High Time Complexity: Both insertion and deletion in an array have an average time complexity of \\(O(n)\\), where \\(n\\) is the length of the array.
    • Loss of Elements: Due to the fixed length of arrays, elements that exceed the array's capacity are lost during insertion.
    • Waste of Memory: Initializing a longer array and utilizing only the front part results in \"meaningless\" end elements during insertion, leading to some wasted memory space.
    "},{"location":"chapter_array_and_linkedlist/array/#5-traversing-arrays","title":"5. \u00a0 Traversing Arrays","text":"

    In most programming languages, we can traverse an array either by using indices or by directly iterating over each element:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def traverse(nums: list[int]):\n    \"\"\"\u904d\u5386\u6570\u7ec4\"\"\"\n    count = 0\n    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in range(len(nums)):\n        count += nums[i]\n    # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums:\n        count += num\n    # \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n
    array.cpp
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        count += nums[i];\n    }\n}\n
    array.java
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (int num : nums) {\n        count += num;\n    }\n}\n
    array.cs
    /* \u904d\u5386\u6570\u7ec4 */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < nums.Length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n
    array.go
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums []int) {\n    count := 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i := 0; i < len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for _, num := range nums {\n        count += num\n    }\n    // \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n
    array.swift
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums {\n        count += num\n    }\n    // \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n
    array.js
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums) {\n    let count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (let i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (const num of nums) {\n        count += num;\n    }\n}\n
    array.ts
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (let i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (const num of nums) {\n        count += num;\n    }\n}\n
    array.dart
    /* \u904d\u5386\u6570\u7ec4\u5143\u7d20 */\nvoid traverse(List<int> nums) {\n  int count = 0;\n  // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n  for (var i = 0; i < nums.length; i++) {\n    count += nums[i];\n  }\n  // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n  for (int _num in nums) {\n    count += _num;\n  }\n  // \u901a\u8fc7 forEach \u65b9\u6cd5\u904d\u5386\u6570\u7ec4\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n
    array.rs
    /* \u904d\u5386\u6570\u7ec4 */\nfn traverse(nums: &[i32]) {\n    let mut _count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums {\n        _count += num;\n    }\n}\n
    array.c
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        count += nums[i];\n    }\n}\n
    array.kt
    /* \u904d\u5386\u6570\u7ec4 */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (j: Int in nums) {\n        count += j\n    }\n}\n
    array.rb
    ### \u904d\u5386\u6570\u7ec4 ###\ndef traverse(nums)\n  count = 0\n\n  # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n  for num in nums\n    count += num\n  end\nend\n
    array.zig
    // \u904d\u5386\u6570\u7ec4\nfn traverse(nums: []i32) void {\n    var count: i32 = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    var i: i32 = 0;\n    while (i < nums.len) : (i += 1) {\n        count += nums[i];\n    }\n    count = 0;\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (nums) |num| {\n        count += num;\n    }\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#6-finding-elements","title":"6. \u00a0 Finding Elements","text":"

    Locating a specific element within an array involves iterating through the array, checking each element to determine if it matches the desired value.

    Because arrays are linear data structures, this operation is commonly referred to as \"linear search.\"

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def find(nums: list[int], target: int) -> int:\n    \"\"\"\u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n
    array.cpp
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i < size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.java
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int[] nums, int target) {\n    for (int i = 0; i < nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.cs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint Find(int[] nums, int target) {\n    for (int i = 0; i < nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.go
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i < len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n
    array.swift
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums: [Int], target: Int) -> Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n
    array.js
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums, target) {\n    for (let i = 0; i < nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n
    array.ts
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i < nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(List<int> nums, int target) {\n  for (var i = 0; i < nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n
    array.rs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfn find(nums: &[i32], target: i32) -> Option<usize> {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n
    array.c
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i < size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.kt
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target) return i\n    }\n    return -1\n}\n
    array.rb
    ### \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n
    array.zig
    // \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\nfn find(nums: []i32, target: i32) i32 {\n    for (nums, 0..) |num, i| {\n        if (num == target) return @intCast(i);\n    }\n    return -1;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#7-expanding-arrays","title":"7. \u00a0 Expanding Arrays","text":"

    In complex system environments, ensuring the availability of memory space after an array for safe capacity extension becomes challenging. Consequently, in most programming languages, the length of an array is immutable.

    To expand an array, it's necessary to create a larger array and then copy the elements from the original array. This operation has a time complexity of \\(O(n)\\) and can be time-consuming for large arrays. The code are as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    res = [0] * (len(nums) + enlarge)\n    # \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res\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\n    int *res = new int[size + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        res[i] = nums[i];\n    }\n    // \u91ca\u653e\u5185\u5b58\n    delete[] nums;\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    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\n    int[] res = new int[nums.length + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\n    int[] res = new int[nums.Length + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\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\n    res := make([]int, len(nums)+enlarge)\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for i, num := range nums {\n        res[i] = num\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\n    var 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\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\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\n    const 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\n    for (let i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\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\n    const 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\n    for (let i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    array.dart
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nList<int> extend(List<int> nums, int enlarge) {\n  // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n  List<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\n  for (var i = 0; i < nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n  return res;\n}\n
    array.rs
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfn extend(nums: Vec<i32>, enlarge: usize) -> Vec<i32> {\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n    let mut res: Vec<i32> = vec![0; nums.len() + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\n    for i in 0..nums.len() {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    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\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        res[i] = nums[i];\n    }\n    // \u521d\u59cb\u5316\u6269\u5c55\u540e\u7684\u7a7a\u95f4\n    for (int i = size; i < size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    array.kt
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n    val res = IntArray(nums.size + enlarge)\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res\n}\n
    array.rb
    ### \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 ###\n# \u8bf7\u6ce8\u610f\uff0cRuby \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\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6570\u7ec4\ndef extend(nums, enlarge)\n  # \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n  res = Array.new(nums.length + enlarge, 0)\n\n  # \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n  res\nend\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\n    var 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\n    std.mem.copy(i32, res, nums);\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#412-advantages-and-limitations-of-arrays","title":"4.1.2 \u00a0 Advantages and Limitations of Arrays","text":"

    Arrays are stored in contiguous memory spaces and consist of elements of the same type. This approach provides substantial prior information that systems can leverage to optimize the efficiency of data structure operations.

    • High Space Efficiency: Arrays allocate a contiguous block of memory for data, eliminating the need for additional structural overhead.
    • Support for Random Access: Arrays allow \\(O(1)\\) time access to any element.
    • Cache Locality: When accessing array elements, the computer not only loads them but also caches the surrounding data, utilizing high-speed cache to enchance subsequent operation speeds.

    However, continuous space storage is a double-edged sword, with the following limitations:

    • Low Efficiency in Insertion and Deletion: As arrays accumulate many elements, inserting or deleting elements requires shifting a large number of elements.
    • Fixed Length: The length of an array is fixed after initialization. Expanding an array requires copying all data to a new array, incurring significant costs.
    • Space Wastage: If the allocated array size exceeds the what is necessary, the extra space is wasted.
    "},{"location":"chapter_array_and_linkedlist/array/#413-typical-applications-of-arrays","title":"4.1.3 \u00a0 Typical Applications of Arrays","text":"

    Arrays are fundamental and widely used data structures. They find frequent application in various algorithms and serve in the implementation of complex data structures.

    • Random Access: Arrays are ideal for storing data when random sampling is required. By generating a random sequence based on indices, we can achieve random sampling efficiently.
    • Sorting and Searching: Arrays are the most commonly used data structure for sorting and searching algorithms. Techniques like quick sort, merge sort, binary search, etc., are primarily operate on arrays.
    • Lookup Tables: Arrays serve as efficient lookup tables for quick element or relationship retrieval. For instance, mapping characters to ASCII codes becomes seamless by using the ASCII code values as indices and storing corresponding elements in the array.
    • Machine Learning: Within the domain of neural networks, arrays play a pivotal role in executing crucial linear algebra operations involving vectors, matrices, and tensors. Arrays serve as the primary and most extensively used data structure in neural network programming.
    • Data Structure Implementation: Arrays serve as the building blocks for implementing various data structures like stacks, queues, hash tables, heaps, graphs, etc. For instance, the adjacency matrix representation of a graph is essentially a two-dimensional array.
    "},{"location":"chapter_array_and_linkedlist/linked_list/","title":"4.2 \u00a0 Linked Lists","text":"

    Memory space is a shared resource among all programs. In a complex system environment, available memory can be dispersed throughout the memory space. We understand that the memory allocated for an array must be continuous. However, for very large arrays, finding a sufficiently large contiguous memory space might be challenging. This is where the flexible advantage of linked lists becomes evident.

    A \"linked list\" is a linear data structure in which each element is a node object, and the nodes are interconnected through \"references\". These references hold the memory addresses of subsequent nodes, enabling navigation from one node to the next.

    The design of linked lists allows for their nodes to be distributed across memory locations without requiring contiguous memory addresses.

    Figure 4-5 \u00a0 Linked List Definition and Storage Method

    As shown in the figure, we see that the basic building block of a linked list is the \"node\" object. Each node comprises two key components: the node's \"value\" and a \"reference\" to the next node.

    • The first node in a linked list is the \"head node\", and the final one is the \"tail node\".
    • The tail node points to \"null\", designated as null in Java, nullptr in C++, and None in Python.
    • In languages that support pointers, like C, C++, Go, and Rust, this \"reference\" is typically implemented as a \"pointer\".

    As the code below illustrates, a ListNode in a linked list, besides holding a value, must also maintain an additional reference (or pointer). Therefore, a linked list occupies more memory space than an array when storing the same quantity of data..

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    class ListNode:\n    \"\"\"Linked List Node Class\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # Node value\n        self.next: ListNode | None = None # Reference to the next node\n
    /* Linked List Node Structure */\nstruct ListNode {\n    int val;         // Node value\n    ListNode *next;  // Pointer to the next node\n    ListNode(int x) : val(x), next(nullptr) {}  // Constructor\n};\n
    /* Linked List Node Class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the next node\n    ListNode(int x) { val = x; }  // Constructor\n}\n
    /* Linked List Node Class */\nclass ListNode(int x) {  // Constructor\n    int val = x;         // Node value\n    ListNode? next;      // Reference to the next node\n}\n
    /* Linked List Node Structure */\ntype ListNode struct {\n    Val  int       // Node value\n    Next *ListNode // Pointer to the next node\n}\n\n// NewListNode Constructor, creates a new linked list\nfunc NewListNode(val int) *ListNode {\n    return &ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n
    /* Linked List Node Class */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Reference to the next node\n\n    init(x: Int) { // Constructor\n        val = x\n    }\n}\n
    /* Linked List Node Class */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // Node value\n        this.next = (next === undefined ? null : next); // Reference to the next node\n    }\n}\n
    /* Linked List Node Class */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // Node value\n        this.next = next === undefined ? null : next;  // Reference to the next node\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n  int val; // Node value\n  ListNode? next; // Reference to the next node\n  ListNode(this.val, [this.next]); // Constructor\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n/* Linked List Node Class */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Node value\n    next: Option<Rc<RefCell<ListNode>>>, // Pointer to the next node\n}\n
    /* Linked List Node Structure */\ntypedef struct ListNode {\n    int val;               // Node value\n    struct ListNode *next; // Pointer to the next node\n} ListNode;\n\n/* Constructor */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node->val = val;\n    node->next = NULL;\n    return node;\n}\n
    \n
    // Linked List Node Class\npub fn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = 0, // Node value\n        next: ?*Self = null, // Pointer to the next node\n\n        // Constructor\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n        }\n    };\n}\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#421-common-operations-on-linked-lists","title":"4.2.1 \u00a0 Common Operations on Linked Lists","text":""},{"location":"chapter_array_and_linkedlist/linked_list/#1-initializing-a-linked-list","title":"1. \u00a0 Initializing a Linked List","text":"

    Constructing a linked list is a two-step process: first, initializing each node object, and second, forming the reference links between the nodes. After initialization, we can traverse all nodes sequentially from the head node by following the next reference.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig linked_list.py
    # Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4\n# Initialize each node\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n
    linked_list.cpp
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.java
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.cs
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.go
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// Build references between nodes\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n
    linked_list.swift
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n
    linked_list.js
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.ts
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.dart
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.rs
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// Build references between nodes\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n
    linked_list.c
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// Build references between nodes\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.kt
    \n
    linked_list.zig
    // Initialize linked list\n// Initialize each node\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// Build references between nodes\nn0.next = &n1;\nn1.next = &n2;\nn2.next = &n3;\nn3.next = &n4;\n

    The array as a whole is a variable, for instance, the array nums includes elements like nums[0], nums[1], and so on, whereas a linked list is made up of several distinct node objects. We typically refer to a linked list by its head node, for example, the linked list in the previous code snippet is referred to as n0.

    "},{"location":"chapter_array_and_linkedlist/linked_list/#2-inserting-a-node","title":"2. \u00a0 Inserting a Node","text":"

    Inserting a node into a linked list is very easy. As shown in the figure, let's assume we aim to insert a new node P between two adjacent nodes n0 and n1. This can be achieved by simply modifying two node references (pointers), with a time complexity of \\(O(1)\\).

    By comparison, inserting an element into an array has a time complexity of \\(O(n)\\), which becomes less efficient when dealing with large data volumes.

    Figure 4-6 \u00a0 Linked List Node Insertion Example

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def insert(n0: ListNode, P: ListNode):\n    \"\"\"\u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0->next;\n    P->next = n1;\n    n0->next = P;\n}\n
    linked_list.java
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.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) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n
    linked_list.go
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.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) {\n    let n1 = n0.next\n    P.next = n1\n    n0.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) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.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 {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.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) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n
    linked_list.rs
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\n#[allow(non_snake_case)]\npub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(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) {\n    ListNode *n1 = n0->next;\n    P->next = n1;\n    n0->next = P;\n}\n
    linked_list.kt
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9p */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n
    linked_list.rb
    ### \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 _p ###\n# Ruby \u7684 `p` \u662f\u4e00\u4e2a\u5185\u7f6e\u51fd\u6570\uff0c `P` \u662f\u4e00\u4e2a\u5e38\u91cf\uff0c\u6240\u4ee5\u53ef\u4ee5\u4f7f\u7528 `_p` \u4ee3\u66ff\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\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 {\n    var n1 = n0.?.next;\n    P.?.next = n1;\n    n0.?.next = P;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#3-deleting-a-node","title":"3. \u00a0 Deleting a Node","text":"

    As shown in the figure, deleting a node from a linked list is also very easy, involving only the modification of a single node's reference (pointer).

    It's important to note that even though node P continues to point to n1 after being deleted, it becomes inaccessible during linked list traversal. This effectively means that P is no longer a part of the linked list.

    Figure 4-7 \u00a0 Linked List Node Deletion

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def remove(n0: ListNode):\n    \"\"\"\u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9\"\"\"\n    if not n0.next:\n        return\n    # n0 -> P -> n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n
    linked_list.cpp
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode *n0) {\n    if (n0->next == nullptr)\n        return;\n    // n0 -> P -> n1\n    ListNode *P = n0->next;\n    ListNode *n1 = P->next;\n    n0->next = n1;\n    // \u91ca\u653e\u5185\u5b58\n    delete P;\n}\n
    linked_list.java
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -> P -> n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n
    linked_list.cs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -> P -> n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n
    linked_list.go
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -> P -> n1\n    P := n0.Next\n    n1 := P.Next\n    n0.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) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -> P -> n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.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) {\n    if (!n0.next) return;\n    // n0 -> P -> n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.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 {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -> P -> n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.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) {\n  if (n0.next == null) return;\n  // n0 -> P -> n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n
    linked_list.rs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\n#[allow(non_snake_case)]\npub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {\n    if n0.borrow().next.is_none() {\n        return;\n    };\n    // n0 -> P -> n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\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 removeItem(ListNode *n0) {\n    if (!n0->next)\n        return;\n    // n0 -> P -> n1\n    ListNode *P = n0->next;\n    ListNode *n1 = P->next;\n    n0->next = n1;\n    // \u91ca\u653e\u5185\u5b58\n    free(P);\n}\n
    linked_list.kt
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfun remove(n0: ListNode?) {\n    val p = n0?.next\n    val n1 = p?.next\n    n0?.next = n1\n}\n
    linked_list.rb
    ### \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -> remove_node -> n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\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 {\n    if (n0.?.next == null) return;\n    // n0 -> P -> n1\n    var P = n0.?.next;\n    var n1 = P.?.next;\n    n0.?.next = n1;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#4-accessing-nodes","title":"4. \u00a0 Accessing Nodes","text":"

    Accessing nodes in a linked list is less efficient. As previously mentioned, any element in an array can be accessed in \\(O(1)\\) time. In contrast, with a linked list, the program involves starting from the head node and sequentially traversing through the nodes until the desired node is found. In other words, to access the \\(i\\)-th node in a linked list, the program must iterate through \\(i - 1\\) nodes, resulting in a time complexity of \\(O(n)\\).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def access(head: ListNode, index: int) -> ListNode | None:\n    \"\"\"\u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n
    linked_list.cpp
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head->next;\n    }\n    return head;\n}\n
    linked_list.java
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.cs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.go
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i < index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return 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? {\n    var head: ListNode? = head\n    for _ in 0 ..< index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n
    linked_list.js
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunction access(head, index) {\n    for (let i = 0; i < index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return 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 {\n    for (let i = 0; i < index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.dart
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i < index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n
    linked_list.rs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\npub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {\n    if index <= 0 {\n        return head;\n    };\n    if let Some(node) = &head.borrow().next {\n        return access(node.clone(), index - 1);\n    }\n\n    return head;\n}\n
    linked_list.c
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head->next;\n    }\n    return head;\n}\n
    linked_list.kt
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..<index) {\n        h = h?.next\n    }\n    return h\n}\n
    linked_list.rb
    ### \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\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) {\n    var head = node;\n    var i: i32 = 0;\n    while (i < index) : (i += 1) {\n        head = head.?.next;\n        if (head == null) return null;\n    }\n    return head;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#5-finding-nodes","title":"5. \u00a0 Finding Nodes","text":"

    Traverse the linked list to locate a node whose value matches target, and then output the index of that node within the linked list. This procedure is also an example of linear search. The corresponding code is provided below:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head->val == target)\n            return index;\n        head = head->next;\n        index++;\n    }\n    return -1;\n}\n
    linked_list.java
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -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) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\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 {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -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 {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n
    linked_list.js
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -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 {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -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) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n
    linked_list.rs
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\npub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {\n    if head.borrow().val == target {\n        return index;\n    };\n    if let Some(node) = &head.borrow_mut().next {\n        return find(node.clone(), target, index + 1);\n    }\n    return -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) {\n    int index = 0;\n    while (head) {\n        if (head->val == target)\n            return index;\n        head = head->next;\n        index++;\n    }\n    return -1;\n}\n
    linked_list.kt
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h.value == target) return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n
    linked_list.rb
    ### \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\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 {\n    var head = node;\n    var index: i32 = 0;\n    while (head != null) {\n        if (head.?.val == target) return index;\n        head = head.?.next;\n        index += 1;\n    }\n    return -1;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#422-arrays-vs-linked-lists","title":"4.2.2 \u00a0 Arrays vs. Linked Lists","text":"

    The Table 4-1 summarizes the characteristics of arrays and linked lists, and it also compares their efficiencies in various operations. Because they utilize opposing storage strategies, their respective properties and operational efficiencies exhibit distinct contrasts.

    Table 4-1 \u00a0 Efficiency Comparison of Arrays and Linked Lists

    Arrays Linked Lists Storage Contiguous Memory Space Dispersed Memory Space Capacity Expansion Fixed Length Flexible Expansion Memory Efficiency Less Memory per Element, Potential Space Wastage More Memory per Element Accessing Elements \\(O(1)\\) \\(O(n)\\) Adding Elements \\(O(n)\\) \\(O(1)\\) Deleting Elements \\(O(n)\\) \\(O(1)\\)"},{"location":"chapter_array_and_linkedlist/linked_list/#423-common-types-of-linked-lists","title":"4.2.3 \u00a0 Common Types of Linked Lists","text":"

    As shown in the figure, there are three common types of linked lists.

    • Singly Linked List: This is the standard linked list described earlier. Nodes in a singly linked list include a value and a reference to the next node. The first node is known as the head node, and the last node, which points to null (None), is the tail node.
    • Circular Linked List: This is formed when the tail node of a singly linked list points back to the head node, creating a loop. In a circular linked list, any node can function as the head node.
    • Doubly Linked List: In contrast to a singly linked list, a doubly linked list maintains references in two directions. Each node contains references (pointer) to both its successor (the next node) and predecessor (the previous node). Although doubly linked lists offer more flexibility for traversing in either direction, they also consume more memory space.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    class ListNode:\n    \"\"\"Bidirectional linked list node class\"\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Node value\n        self.next: ListNode | None = None  # Reference to the successor node\n        self.prev: ListNode | None = None  # Reference to a predecessor node\n
    /* Bidirectional linked list node structure */\nstruct ListNode {\n    int val;         // Node value\n    ListNode *next;  // Pointer to the successor node\n    ListNode *prev;  // Pointer to the predecessor node\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // Constructor\n};\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the next node\n    ListNode prev;  // Reference to the predecessor node\n    ListNode(int x) { val = x; }  // Constructor\n}\n
    /* Bidirectional linked list node class */\nclass ListNode(int x) {  // Constructor\n    int val = x;    // Node value\n    ListNode next;  // Reference to the next node\n    ListNode prev;  // Reference to the predecessor node\n}\n
    /* Bidirectional linked list node structure */\ntype DoublyListNode struct {\n    Val  int             // Node value\n    Next *DoublyListNode // Pointer to the successor node\n    Prev *DoublyListNode // Pointer to the predecessor node\n}\n\n// NewDoublyListNode initialization\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Reference to the next node\n    var prev: ListNode? // Reference to the predecessor node\n\n    init(x: Int) { // Constructor\n        val = x\n    }\n}\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // Node value\n        this.next = next  ===  undefined ? null : next;  // Reference to the successor node\n        this.prev = prev  ===  undefined ? null : prev;  // Reference to the predecessor node\n    }\n}\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // Node value\n        this.next = next  ===  undefined ? null : next;  // Reference to the successor node\n        this.prev = prev  ===  undefined ? null : prev;  // Reference to the predecessor node\n    }\n}\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the next node\n    ListNode prev;  // Reference to the predecessor node\n    ListNode(this.val, [this.next, this.prev]);  // Constructor\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Bidirectional linked list node type */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Node value\n    next: Option<Rc<RefCell<ListNode>>>, // Pointer to successor node\n    prev: Option<Rc<RefCell<ListNode>>>, // Pointer to predecessor node\n}\n\n/* Constructors */\nimpl ListNode {\n    fn new(val: i32) -> Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n
    /* Bidirectional linked list node structure */\ntypedef struct ListNode {\n    int val;               // Node value\n    struct ListNode *next; // Pointer to the successor node\n    struct ListNode *prev; // Pointer to the predecessor node\n} ListNode;\n\n/* Constructors */\nListNode *newListNode(int val) {\n    ListNode *node, *next;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node->val = val;\n    node->next = NULL;\n    node->prev = NULL;\n    return node;\n}\n
    \n
    // Bidirectional linked list node class\npub fn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = 0, // Node value\n        next: ?*Self = null, // Pointer to the successor node\n        prev: ?*Self = null, // Pointer to the predecessor node\n\n        // Constructor\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n            self.prev = null;\n        }\n    };\n}\n

    Figure 4-8 \u00a0 Common Types of Linked Lists

    "},{"location":"chapter_array_and_linkedlist/linked_list/#424-typical-applications-of-linked-lists","title":"4.2.4 \u00a0 Typical Applications of Linked Lists","text":"

    Singly linked lists are frequently utilized in implementing stacks, queues, hash tables, and graphs.

    • Stacks and Queues: In singly linked lists, if insertions and deletions occur at the same end, it behaves like a stack (last-in-first-out). Conversely, if insertions are at one end and deletions at the other, it functions like a queue (first-in-first-out).
    • Hash Tables: Linked lists are used in chaining, a popular method for resolving hash collisions. Here, all collided elements are grouped into a linked list.
    • Graphs: Adjacency lists, a standard method for graph representation, associate each graph vertex with a linked list. This list contains elements that represent vertices connected to the corresponding vertex.

    Doubly linked lists are ideal for scenarios requiring rapid access to preceding and succeeding elements.

    • Advanced Data Structures: In structures like red-black trees and B-trees, accessing a node's parent is essential. This is achieved by incorporating a reference to the parent node in each node, akin to a doubly linked list.
    • Browser History: In web browsers, doubly linked lists facilitate navigating the history of visited pages when users click forward or back.
    • LRU Algorithm: Doubly linked lists are apt for Least Recently Used (LRU) cache eviction algorithms, enabling swift identification of the least recently used data and facilitating fast node addition and removal.

    Circular linked lists are ideal for applications that require periodic operations, such as resource scheduling in operating systems.

    • Round-Robin Scheduling Algorithm: In operating systems, the round-robin scheduling algorithm is a common CPU scheduling method, requiring cycling through a group of processes. Each process is assigned a time slice, and upon expiration, the CPU rotates to the next process. This cyclical operation can be efficiently realized using a circular linked list, allowing for a fair and time-shared system among all processes.
    • Data Buffers: Circular linked lists are also used in data buffers, like in audio and video players, where the data stream is divided into multiple buffer blocks arranged in a circular fashion for seamless playback.
    "},{"location":"chapter_array_and_linkedlist/list/","title":"4.3 \u00a0 List","text":"

    A \"list\" is an abstract data structure concept that represents an ordered collection of elements, supporting operations such as element access, modification, addition, deletion, and traversal, without requiring users to consider capacity limitations. Lists can be implemented based on linked lists or arrays.

    • A linked list inherently serves as a list, supporting operations for adding, deleting, searching, and modifying elements, with the flexibility to dynamically adjust its size.
    • Arrays also support these operations, but due to their immutable length, they can be considered as a list with a length limit.

    When implementing lists using arrays, the immutability of length reduces the practicality of the list. This is because predicting the amount of data to be stored in advance is often challenging, making it difficult to choose an appropriate list length. If the length is too small, it may not meet the requirements; if too large, it may waste memory space.

    To solve this problem, we can implement lists using a \"dynamic array.\" It inherits the advantages of arrays and can dynamically expand during program execution.

    In fact, many programming languages' standard libraries implement lists using dynamic arrays, such as Python's list, Java's ArrayList, C++'s vector, and C#'s List. In the following discussion, we will consider \"list\" and \"dynamic array\" as synonymous concepts.

    "},{"location":"chapter_array_and_linkedlist/list/#431-common-list-operations","title":"4.3.1 \u00a0 Common List Operations","text":""},{"location":"chapter_array_and_linkedlist/list/#1-initializing-a-list","title":"1. \u00a0 Initializing a List","text":"

    We typically use two initialization methods: \"without initial values\" and \"with initial values\".

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Initialize list\n# Without initial values\nnums1: list[int] = []\n# With initial values\nnums: list[int] = [1, 3, 2, 5, 4]\n
    list.cpp
    /* Initialize list */\n// Note, in C++ the vector is the equivalent of nums described here\n// Without initial values\nvector<int> nums1;\n// With initial values\nvector<int> nums = { 1, 3, 2, 5, 4 };\n
    list.java
    /* Initialize list */\n// Without initial values\nList<Integer> nums1 = new ArrayList<>();\n// With initial values (note the element type should be the wrapper class Integer[] for int[])\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList<Integer> nums = new ArrayList<>(Arrays.asList(numbers));\n
    list.cs
    /* Initialize list */\n// Without initial values\nList<int> nums1 = [];\n// With initial values\nint[] numbers = [1, 3, 2, 5, 4];\nList<int> nums = [.. numbers];\n
    list_test.go
    /* Initialize list */\n// Without initial values\nnums1 := []int{}\n// With initial values\nnums := []int{1, 3, 2, 5, 4}\n
    list.swift
    /* Initialize list */\n// Without initial values\nlet nums1: [Int] = []\n// With initial values\nvar nums = [1, 3, 2, 5, 4]\n
    list.js
    /* Initialize list */\n// Without initial values\nconst nums1 = [];\n// With initial values\nconst nums = [1, 3, 2, 5, 4];\n
    list.ts
    /* Initialize list */\n// Without initial values\nconst nums1: number[] = [];\n// With initial values\nconst nums: number[] = [1, 3, 2, 5, 4];\n
    list.dart
    /* Initialize list */\n// Without initial values\nList<int> nums1 = [];\n// With initial values\nList<int> nums = [1, 3, 2, 5, 4];\n
    list.rs
    /* Initialize list */\n// Without initial values\nlet nums1: Vec<i32> = Vec::new();\n// With initial values\nlet nums: Vec<i32> = vec![1, 3, 2, 5, 4];\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Initialize list\nvar nums = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nums.deinit();\ntry nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });\n
    "},{"location":"chapter_array_and_linkedlist/list/#2-accessing-elements","title":"2. \u00a0 Accessing Elements","text":"

    Lists are essentially arrays, thus they can access and update elements in \\(O(1)\\) time, which is very efficient.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Access elements\nnum: int = nums[1]  # Access the element at index 1\n\n# Update elements\nnums[1] = 0    # Update the element at index 1 to 0\n
    list.cpp
    /* Access elements */\nint num = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list.java
    /* Access elements */\nint num = nums.get(1);  // Access the element at index 1\n\n/* Update elements */\nnums.set(1, 0);  // Update the element at index 1 to 0\n
    list.cs
    /* Access elements */\nint num = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list_test.go
    /* Access elements */\nnum := nums[1]  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0     // Update the element at index 1 to 0\n
    list.swift
    /* Access elements */\nlet num = nums[1] // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0 // Update the element at index 1 to 0\n
    list.js
    /* Access elements */\nconst num = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list.ts
    /* Access elements */\nconst num: number = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list.dart
    /* Access elements */\nint num = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list.rs
    /* Access elements */\nlet num: i32 = nums[1];  // Access the element at index 1\n/* Update elements */\nnums[1] = 0;             // Update the element at index 1 to 0\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Access elements\nvar num = nums.items[1]; // Access the element at index 1\n\n// Update elements\nnums.items[1] = 0; // Update the element at index 1 to 0  \n
    "},{"location":"chapter_array_and_linkedlist/list/#3-inserting-and-removing-elements","title":"3. \u00a0 Inserting and Removing Elements","text":"

    Compared to arrays, lists offer more flexibility in adding and removing elements. While adding elements to the end of a list is an \\(O(1)\\) operation, the efficiency of inserting and removing elements elsewhere in the list remains the same as in arrays, with a time complexity of \\(O(n)\\).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Clear list\nnums.clear()\n\n# Append elements at the end\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# Insert element in the middle\nnums.insert(3, 6)  # Insert number 6 at index 3\n\n# Remove elements\nnums.pop(3)        # Remove the element at index 3\n
    list.cpp
    /* Clear list */\nnums.clear();\n\n/* Append elements at the end */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* Insert element in the middle */\nnums.insert(nums.begin() + 3, 6);  // Insert number 6 at index 3\n\n/* Remove elements */\nnums.erase(nums.begin() + 3);      // Remove the element at index 3\n
    list.java
    /* Clear list */\nnums.clear();\n\n/* Append elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert element in the middle */\nnums.add(3, 6);  // Insert number 6 at index 3\n\n/* Remove elements */\nnums.remove(3);  // Remove the element at index 3\n
    list.cs
    /* Clear list */\nnums.Clear();\n\n/* Append elements at the end */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* Insert element in the middle */\nnums.Insert(3, 6);\n\n/* Remove elements */\nnums.RemoveAt(3);\n
    list_test.go
    /* Clear list */\nnums = nil\n\n/* Append elements at the end */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* Insert element in the middle */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // Insert number 6 at index 3\n\n/* Remove elements */\nnums = append(nums[:3], nums[4:]...) // Remove the element at index 3\n
    list.swift
    /* Clear list */\nnums.removeAll()\n\n/* Append elements at the end */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* Insert element in the middle */\nnums.insert(6, at: 3) // Insert number 6 at index 3\n\n/* Remove elements */\nnums.remove(at: 3) // Remove the element at index 3\n
    list.js
    /* Clear list */\nnums.length = 0;\n\n/* Append elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert element in the middle */\nnums.splice(3, 0, 6);\n\n/* Remove elements */\nnums.splice(3, 1);\n
    list.ts
    /* Clear list */\nnums.length = 0;\n\n/* Append elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert element in the middle */\nnums.splice(3, 0, 6);\n\n/* Remove elements */\nnums.splice(3, 1);\n
    list.dart
    /* Clear list */\nnums.clear();\n\n/* Append elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert element in the middle */\nnums.insert(3, 6); // Insert number 6 at index 3\n\n/* Remove elements */\nnums.removeAt(3); // Remove the element at index 3\n
    list.rs
    /* Clear list */\nnums.clear();\n\n/* Append elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert element in the middle */\nnums.insert(3, 6);  // Insert number 6 at index 3\n\n/* Remove elements */\nnums.remove(3);    // Remove the element at index 3\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Clear list\nnums.clearRetainingCapacity();\n\n// Append elements at the end\ntry nums.append(1);\ntry nums.append(3);\ntry nums.append(2);\ntry nums.append(5);\ntry nums.append(4);\n\n// Insert element in the middle\ntry nums.insert(3, 6); // Insert number 6 at index 3\n\n// Remove elements\n_ = nums.orderedRemove(3); // Remove the element at index 3\n
    "},{"location":"chapter_array_and_linkedlist/list/#4-iterating-the-list","title":"4. \u00a0 Iterating the List","text":"

    Similar to arrays, lists can be iterated either by using indices or by directly iterating through each element.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Iterate through the list by index\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# Iterate directly through list elements\nfor num in nums:\n    count += num\n
    list.cpp
    /* Iterate through the list by index */\nint count = 0;\nfor (int i = 0; i < nums.size(); i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n
    list.java
    /* Iterate through the list by index */\nint count = 0;\nfor (int i = 0; i < nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* Iterate directly through list elements */\nfor (int num : nums) {\n    count += num;\n}\n
    list.cs
    /* Iterate through the list by index */\nint count = 0;\nfor (int i = 0; i < nums.Count; i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n
    list_test.go
    /* Iterate through the list by index */\ncount := 0\nfor i := 0; i < len(nums); i++ {\n    count += nums[i]\n}\n\n/* Iterate directly through list elements */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n
    list.swift
    /* Iterate through the list by index */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* Iterate directly through list elements */\ncount = 0\nfor num in nums {\n    count += num\n}\n
    list.js
    /* Iterate through the list by index */\nlet count = 0;\nfor (let i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n
    list.ts
    /* Iterate through the list by index */\nlet count = 0;\nfor (let i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n
    list.dart
    /* Iterate through the list by index */\nint count = 0;\nfor (var i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n
    list.rs
    // Iterate through the list by index\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// Iterate directly through list elements\n_count = 0;\nfor num in &nums {\n    _count += num;\n}\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Iterate through the list by index\nvar count: i32 = 0;\nvar i: i32 = 0;\nwhile (i < nums.items.len) : (i += 1) {\n    count += nums[i];\n}\n\n// Iterate directly through list elements\ncount = 0;\nfor (nums.items) |num| {\n    count += num;\n}\n
    "},{"location":"chapter_array_and_linkedlist/list/#5-concatenating-lists","title":"5. \u00a0 Concatenating Lists","text":"

    Given a new list nums1, we can append it to the end of the original list.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Concatenate two lists\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # Concatenate nums1 to the end of nums\n
    list.cpp
    /* Concatenate two lists */\nvector<int> nums1 = { 6, 8, 7, 10, 9 };\n// Concatenate nums1 to the end of nums\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n
    list.java
    /* Concatenate two lists */\nList<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // Concatenate nums1 to the end of nums\n
    list.cs
    /* Concatenate two lists */\nList<int> nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // Concatenate nums1 to the end of nums\n
    list_test.go
    /* Concatenate two lists */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // Concatenate nums1 to the end of nums\n
    list.swift
    /* Concatenate two lists */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // Concatenate nums1 to the end of nums\n
    list.js
    /* Concatenate two lists */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Concatenate nums1 to the end of nums\n
    list.ts
    /* Concatenate two lists */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Concatenate nums1 to the end of nums\n
    list.dart
    /* Concatenate two lists */\nList<int> nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // Concatenate nums1 to the end of nums\n
    list.rs
    /* Concatenate two lists */\nlet nums1: Vec<i32> = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Concatenate two lists\nvar nums1 = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nums1.deinit();\ntry nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });\ntry nums.insertSlice(nums.items.len, nums1.items); // Concatenate nums1 to the end of nums\n
    "},{"location":"chapter_array_and_linkedlist/list/#6-sorting-the-list","title":"6. \u00a0 Sorting the List","text":"

    Once the list is sorted, we can employ algorithms commonly used in array-related algorithm problems, such as \"binary search\" and \"two-pointer\" algorithms.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Sort the list\nnums.sort()  # After sorting, the list elements are in ascending order\n
    list.cpp
    /* Sort the list */\nsort(nums.begin(), nums.end());  // After sorting, the list elements are in ascending order\n
    list.java
    /* Sort the list */\nCollections.sort(nums);  // After sorting, the list elements are in ascending order\n
    list.cs
    /* Sort the list */\nnums.Sort(); // After sorting, the list elements are in ascending order\n
    list_test.go
    /* Sort the list */\nsort.Ints(nums)  // After sorting, the list elements are in ascending order\n
    list.swift
    /* Sort the list */\nnums.sort() // After sorting, the list elements are in ascending order\n
    list.js
    /* Sort the list */  \nnums.sort((a, b) => a - b);  // After sorting, the list elements are in ascending order\n
    list.ts
    /* Sort the list */\nnums.sort((a, b) => a - b);  // After sorting, the list elements are in ascending order\n
    list.dart
    /* Sort the list */\nnums.sort(); // After sorting, the list elements are in ascending order\n
    list.rs
    /* Sort the list */\nnums.sort(); // After sorting, the list elements are in ascending order\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Sort the list\nstd.sort.sort(i32, nums.items, {}, comptime std.sort.asc(i32));\n
    "},{"location":"chapter_array_and_linkedlist/list/#432-list-implementation","title":"4.3.2 \u00a0 List Implementation","text":"

    Many programming languages come with built-in lists, including Java, C++, Python, etc. Their implementations tend to be intricate, featuring carefully considered settings for various parameters, like initial capacity and expansion factors. Readers who are curious can delve into the source code for further learning.

    To enhance our understanding of how lists work, we will attempt to implement a simplified version of a list, focusing on three crucial design aspects:

    • Initial Capacity: Choose a reasonable initial capacity for the array. In this example, we choose 10 as the initial capacity.
    • Size Recording: Declare a variable size to record the current number of elements in the list, updating in real-time with element insertion and deletion. With this variable, we can locate the end of the list and determine whether expansion is needed.
    • Expansion Mechanism: If the list reaches full capacity upon an element insertion, an expansion process is required. This involves creating a larger array based on the expansion factor, and then transferring all elements from the current array to the new one. In this example, we stipulate that the array size should double with each expansion.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_list.py
    class MyList:\n    \"\"\"\u5217\u8868\u7c7b\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._capacity: int = 10  # \u5217\u8868\u5bb9\u91cf\n        self._arr: list[int] = [0] * self._capacity  # \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        self._size: int = 0  # \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        self._extend_ratio: int = 2  # \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\"\"\"\n        return self._size\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u5217\u8868\u5bb9\u91cf\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -> int:\n        \"\"\"\u8bbf\u95ee\u5143\u7d20\"\"\"\n        # \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"\u66f4\u65b0\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"\u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\"\"\"\n        # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"\u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self._size += 1\n\n    def remove(self, index: int) -> int:\n        \"\"\"\u5220\u9664\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        num = self._arr[index]\n        # \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self._size -= 1\n        # \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n\n    def extend_capacity(self):\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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        self._capacity = len(self._arr)\n\n    def to_array(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u6709\u6548\u957f\u5ea6\u7684\u5217\u8868\"\"\"\n        return self._arr[: self._size]\n
    my_list.cpp
    /* \u5217\u8868\u7c7b */\nclass MyList {\n  private:\n    int *arr;             // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    int arrCapacity = 10; // \u5217\u8868\u5bb9\u91cf\n    int arrSize = 0;      // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    int extendRatio = 2;   // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    int size() {\n        return arrSize;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    int get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    void set(int index, int num) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    void add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    void insert(int index, int num) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size() == capacity())\n            extendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = size() - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    int remove(int index) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    void extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // \u91ca\u653e\u5185\u5b58\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Vector \u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> vec(size());\n        for (int i = 0; i < size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n
    my_list.java
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private int[] arr; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private int capacity = 10; // \u5217\u8868\u5bb9\u91cf\n    private int size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private int extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\n    public int size() {\n        return size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public int get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public void set(int index, int num) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public void add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public void insert(int index, int num) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = size - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public int remove(int index) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public 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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        capacity = arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public int[] toArray() {\n        int size = size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] arr = new int[size];\n        for (int i = 0; i < size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.cs
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private int[] arr;           // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private int arrCapacity = 10;    // \u5217\u8868\u5bb9\u91cf\n    private int arrSize = 0;         // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private readonly int extendRatio = 2;  // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    public int Size() {\n        return arrSize;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public int Get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public void Set(int index, int num) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public void Add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public void Insert(int index, int num) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = arrSize - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public int Remove(int index) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public void ExtendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a arrCapacity * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        arrCapacity = arr.Length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] arr = new int[arrSize];\n        for (int i = 0; i < arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.go
    /* \u5217\u8868\u7c7b */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newMyList() *myList {\n    return &myList{\n        arrCapacity: 10,              // \u5217\u8868\u5bb9\u91cf\n        arr:         make([]int, 10), // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        arrSize:     0,               // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        extendRatio: 2,               // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n    }\n}\n\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/*  \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nfunc (l *myList) get(index int) int {\n    // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    return l.arr[index]\n}\n\n/* \u66f4\u65b0\u5143\u7d20 */\nfunc (l *myList) set(num, index int) {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    l.arr[index] = num\n}\n\n/* \u5728\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\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize++\n}\n\n/* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nfunc (l *myList) insert(num, index int) {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for j := l.arrSize - 1; j >= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize++\n}\n\n/* \u5220\u9664\u5143\u7d20 */\nfunc (l *myList) remove(index int) int {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    num := l.arr[index]\n    // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for j := index; j < l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize--\n    // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    return num\n}\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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    l.arrCapacity = len(l.arr)\n}\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\n    return l.arr[:l.arrSize]\n}\n
    my_list.swift
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private var arr: [Int] // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private var _capacity: Int // \u5217\u8868\u5bb9\u91cf\n    private var _size: Int // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private let extendRatio: Int // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    func size() -> Int {\n        _size\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    func capacity() -> Int {\n        _capacity\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    func get(index: Int) -> Int {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u9519\u8bef\uff0c\u4e0b\u540c\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        return arr[index]\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    func set(index: Int, num: Int) {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        arr[index] = num\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    func add(num: Int) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size += 1\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    func insert(index: Int, num: Int) {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in (index ..< size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size += 1\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    @discardableResult\n    func remove(index: Int) -> Int {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        let num = arr[index]\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in index ..< (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size -= 1\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    func extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        _capacity = arr.count\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    func toArray() -> [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n
    my_list.js
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    #arr = 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\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    #extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    size() {\n        return this.#size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    get(index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        return this.#arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    set(index, num) {\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        this.#arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    add(num) {\n        // \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    insert(index, num) {\n        if (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\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (let j = this.#size - 1; j >= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    remove(index) {\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        let num = this.#arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (let j = index; j < this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.#size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        this.#capacity = this.#arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    toArray() {\n        let size = this.size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(size);\n        for (let i = 0; i < size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.ts
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private arr: Array<number>; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private _capacity: number = 10; // \u5217\u8868\u5bb9\u91cf\n    private _size: number = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private extendRatio: number = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    public size(): number {\n        return this._size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public get(index: number): number {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        return this.arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public set(index: number, num: number): void {\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        this.arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public add(num: number): void {\n        // \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\n        if (this._size === this._capacity) this.extendCapacity();\n        // \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public insert(index: number, num: number): void {\n        if (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\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (let j = this._size - 1; j >= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public remove(index: number): number {\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        let num = this.arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (let j = index; j < this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this._size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public extendCapacity(): void {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        this._capacity = this.arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public toArray(): number[] {\n        let size = this.size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(size);\n        for (let i = 0; i < size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.dart
    /* \u5217\u8868\u7c7b */\nclass MyList {\n  late List<int> _arr; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n  int _capacity = 10; // \u5217\u8868\u5bb9\u91cf\n  int _size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n  int _extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n  int size() => _size;\n\n  /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n  int capacity() => _capacity;\n\n  /* \u8bbf\u95ee\u5143\u7d20 */\n  int get(int index) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    return _arr[index];\n  }\n\n  /* \u66f4\u65b0\u5143\u7d20 */\n  void set(int index, int _num) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    _arr[index] = _num;\n  }\n\n  /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n  void add(int _num) {\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size++;\n  }\n\n  /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n  void insert(int index, int _num) {\n    if (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\n    if (_size == _capacity) extendCapacity();\n    // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for (var j = _size - 1; j >= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size++;\n  }\n\n  /* \u5220\u9664\u5143\u7d20 */\n  int remove(int index) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    int _num = _arr[index];\n    // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (var j = index; j < _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size--;\n    // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    return _num;\n  }\n\n  /* \u5217\u8868\u6269\u5bb9 */\n  void extendCapacity() {\n    // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 _extendRatio \u500d\u7684\u65b0\u6570\u7ec4\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // \u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    List.copyRange(_newNums, 0, _arr);\n    // \u66f4\u65b0 _arr \u7684\u5f15\u7528\n    _arr = _newNums;\n    // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    _capacity = _arr.length;\n  }\n\n  /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n  List<int> toArray() {\n    List<int> arr = [];\n    for (var i = 0; i < _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n
    my_list.rs
    /* \u5217\u8868\u7c7b */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec<i32>,       // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    capacity: usize,     // \u5217\u8868\u5bb9\u91cf\n    size: usize,         // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    extend_ratio: usize, // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(capacity: usize) -> Self {\n        let mut vec = Vec::new();\n        vec.resize(capacity, 0);\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    pub fn size(&self) -> usize {\n        return self.size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    pub fn capacity(&self) -> usize {\n        return self.capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    pub fn get(&self, index: usize) -> i32 {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if index >= self.size {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        return self.arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    pub fn set(&mut self, index: usize, num: i32) {\n        if index >= self.size {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    pub fn add(&mut self, num: i32) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size += 1;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    pub fn insert(&mut self, index: usize, num: i32) {\n        if index >= self.size() {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size += 1;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    pub fn remove(&mut self, index: usize) -> i32 {\n        if index >= self.size() {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        let num = self.arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in (index..self.size - 1) {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size -= 1;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    pub fn extend_capacity(&mut self) {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        self.capacity = new_capacity;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    pub fn to_array(&mut self) -> Vec<i32> {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n
    my_list.c
    /* \u5217\u8868\u7c7b */\ntypedef struct {\n    int *arr;        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    int capacity;    // \u5217\u8868\u5bb9\u91cf\n    int size;        // \u5217\u8868\u5927\u5c0f\n    int extendRatio; // \u5217\u8868\u6bcf\u6b21\u6269\u5bb9\u7684\u500d\u6570\n} MyList;\n\n/* \u6784\u9020\u51fd\u6570 */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums->capacity = 10;\n    nums->arr = malloc(sizeof(int) * nums->capacity);\n    nums->size = 0;\n    nums->extendRatio = 2;\n    return nums;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delMyList(MyList *nums) {\n    free(nums->arr);\n    free(nums);\n}\n\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6 */\nint size(MyList *nums) {\n    return nums->size;\n}\n\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity(MyList *nums) {\n    return nums->capacity;\n}\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(MyList *nums, int index) {\n    assert(index >= 0 && index < nums->size);\n    return nums->arr[index];\n}\n\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(MyList *nums, int index, int num) {\n    assert(index >= 0 && index < nums->size);\n    nums->arr[index] = num;\n}\n\n/* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // \u6269\u5bb9\n    }\n    nums->arr[size(nums)] = num;\n    nums->size++;\n}\n\n/* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index >= 0 && index < size(nums));\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // \u6269\u5bb9\n    }\n    for (int i = size(nums); i > index; --i) {\n        nums->arr[i] = nums->arr[i - 1];\n    }\n    nums->arr[index] = num;\n    nums->size++;\n}\n\n/* \u5220\u9664\u5143\u7d20 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nint removeItem(MyList *nums, int index) {\n    assert(index >= 0 && index < size(nums));\n    int num = nums->arr[index];\n    for (int i = index; i < size(nums) - 1; i++) {\n        nums->arr[i] = nums->arr[i + 1];\n    }\n    nums->size--;\n    return num;\n}\n\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity(MyList *nums) {\n    // \u5148\u5206\u914d\u7a7a\u95f4\n    int newCapacity = capacity(nums) * nums->extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums->arr;\n\n    // \u62f7\u8d1d\u65e7\u6570\u636e\u5230\u65b0\u6570\u636e\n    for (int i = 0; i < size(nums); i++)\n        extend[i] = nums->arr[i];\n\n    // \u91ca\u653e\u65e7\u6570\u636e\n    free(temp);\n\n    // \u66f4\u65b0\u65b0\u6570\u636e\n    nums->arr = extend;\n    nums->capacity = newCapacity;\n}\n\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Array \u7528\u4e8e\u6253\u5370 */\nint *toArray(MyList *nums) {\n    return nums->arr;\n}\n
    my_list.kt
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private var capacity = 10 // \u5217\u8868\u5bb9\u91cf\n    private var size = 0 // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private var extendRatio = 2 // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\n    fun size(): Int {\n        return size\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    fun get(index: Int): Int {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException()\n        return arr[index]\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    fun set(index: Int, num: Int) {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        arr[index] = num\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    fun add(num: Int) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    fun insert(index: Int, num: Int) {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity()\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    fun remove(index: Int): Int {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        val num: Int = arr[index]\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (j in index..<size - 1)\n            arr[j] = arr[j + 1]\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size--\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    fun extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = arr.copyOf(capacity() * extendRatio)\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        capacity = arr.size\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    fun toArray(): IntArray {\n        val size = size()\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val arr = IntArray(size)\n        for (i in 0..<size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n
    my_list.rb
    ### \u5217\u8868\u7c7b ###\nclass MyList\n  attr_reader :size       # \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n  attr_reader :capacity   # \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\n\n  ### \u6784\u9020\u65b9\u6cd5 ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new capacity\n  end\n\n  ### \u8bbf\u95ee\u5143\u7d20 ###\n  def get(index)\n    # \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    @arr[index]\n  end\n\n  ### \u8bbf\u95ee\u5143\u7d20 ###\n  def set(index, num)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    @arr[index] = num\n  end\n\n  ### \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 ###\n  def add(num)\n    # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size += 1\n  end\n\n  ### \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 ###\n  def insert(index, num)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n\n    # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    extend_capacity if size == capacity\n\n    # \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j] \n    end\n    @arr[index] = num\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size += 1\n  end\n\n  ### \u5220\u9664\u5143\u7d20 ###\n  def remove(index)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    num = @arr[index]\n\n    # \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size -= 1\n\n    # \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    num\n  end\n\n  ### \u5217\u8868\u6269\u5bb9 ###\n  def extend_capacity\n    # \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    @capacity = arr.length\n  end\n\n  ### \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 ###\n  def to_array\n    sz = size\n    # \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    arr = Array.new sz\n    for i in 0...sz\n      arr[i] = get i\n    end\n    arr\n  end\nend\n
    my_list.zig
    // \u5217\u8868\u7c7b\nfn MyList(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        arr: []T = undefined,                        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        arrCapacity: usize = 10,                     // \u5217\u8868\u5bb9\u91cf\n        numSize: usize = 0,                           // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        extendRatio: usize = 2,                       // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined, // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u5217\u8868\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);\n            @memset(self.arr, @as(T, 0));\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        pub fn size(self: *Self) usize {\n            return self.numSize;\n        }\n\n        // \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\n        pub fn capacity(self: *Self) usize {\n            return self.arrCapacity;\n        }\n\n        // \u8bbf\u95ee\u5143\u7d20\n        pub fn get(self: *Self, index: usize) T {\n            // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            return self.arr[index];\n        }  \n\n        // \u66f4\u65b0\u5143\u7d20\n        pub fn set(self: *Self, index: usize, num: T) void {\n            // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            self.arr[index] = num;\n        }  \n\n        // \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\n        pub fn add(self: *Self, num: T) !void {\n            // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n            if (self.size() == self.capacity()) try self.extendCapacity();\n            self.arr[self.size()] = num;\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize += 1;\n        }  \n\n        // \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\n        pub fn insert(self: *Self, index: usize, num: T) !void {\n            if (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\n            if (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\n            var j = self.size() - 1;\n            while (j >= index) : (j -= 1) {\n                self.arr[j + 1] = self.arr[j];\n            }\n            self.arr[index] = num;\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize += 1;\n        }\n\n        // \u5220\u9664\u5143\u7d20\n        pub fn remove(self: *Self, index: usize) T {\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            var num = self.arr[index];\n            // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n            var j = index;\n            while (j < self.size() - 1) : (j += 1) {\n                self.arr[j] = self.arr[j + 1];\n            }\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize -= 1;\n            // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n            return num;\n        }\n\n        // \u5217\u8868\u6269\u5bb9\n        pub fn extendCapacity(self: *Self) !void {\n            // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n            var newCapacity = self.capacity() * self.extendRatio;\n            var 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\n            std.mem.copy(T, extend, self.arr);\n            self.arr = extend;\n            // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n            self.arrCapacity = newCapacity;\n        }\n\n        // \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n            var arr = try self.mem_allocator.alloc(T, self.size());\n           @memset(arr, @as(T, 0));\n            for (arr, 0..) |*num, i| {\n                num.* = self.get(i);\n            }\n            return arr;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/","title":"4.4 \u00a0 Memory and Cache *","text":"

    In the first two sections of this chapter, we explored arrays and linked lists, two fundamental and important data structures, representing \"continuous storage\" and \"dispersed storage\" respectively.

    In fact, the physical structure largely determines the efficiency of a program's use of memory and cache, which in turn affects the overall performance of the algorithm.

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441-computer-storage-devices","title":"4.4.1 \u00a0 Computer Storage Devices","text":"

    There are three types of storage devices in computers: \"hard disk,\" \"random-access memory (RAM),\" and \"cache memory.\" The following table shows their different roles and performance characteristics in computer systems.

    Table 4-2 \u00a0 Computer Storage Devices

    Hard Disk Memory Cache Usage Long-term storage of data, including OS, programs, files, etc. Temporary storage of currently running programs and data being processed Stores frequently accessed data and instructions, reducing the number of CPU accesses to memory Volatility Data is not lost after power off Data is lost after power off Data is lost after power off Capacity Larger, TB level Smaller, GB level Very small, MB level Speed Slower, several hundred to thousands MB/s Faster, several tens of GB/s Very fast, several tens to hundreds of GB/s Price Cheaper, several cents to yuan / GB More expensive, tens to hundreds of yuan / GB Very expensive, priced with CPU

    We can imagine the computer storage system as a pyramid structure shown in the Figure 4-9 . The storage devices closer to the top of the pyramid are faster, have smaller capacity, and are more costly. This multi-level design is not accidental, but the result of careful consideration by computer scientists and engineers.

    • Hard disks are difficult to replace with memory. Firstly, data in memory is lost after power off, making it unsuitable for long-term data storage; secondly, the cost of memory is dozens of times that of hard disks, making it difficult to popularize in the consumer market.
    • It is difficult for caches to have both large capacity and high speed. As the capacity of L1, L2, L3 caches gradually increases, their physical size becomes larger, increasing the physical distance from the CPU core, leading to increased data transfer time and higher element access latency. Under current technology, a multi-level cache structure is the best balance between capacity, speed, and cost.

    Figure 4-9 \u00a0 Computer Storage System

    Note

    The storage hierarchy of computers reflects a delicate balance between speed, capacity, and cost. In fact, this kind of trade-off is common in all industrial fields, requiring us to find the best balance between different advantages and limitations.

    Overall, hard disks are used for long-term storage of large amounts of data, memory is used for temporary storage of data being processed during program execution, and cache is used to store frequently accessed data and instructions to improve program execution efficiency. Together, they ensure the efficient operation of computer systems.

    As shown in the Figure 4-10 , during program execution, data is read from the hard disk into memory for CPU computation. The cache can be considered a part of the CPU, smartly loading data from memory to provide fast data access to the CPU, significantly enhancing program execution efficiency and reducing reliance on slower memory.

    Figure 4-10 \u00a0 Data Flow Between Hard Disk, Memory, and Cache

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442-memory-efficiency-of-data-structures","title":"4.4.2 \u00a0 Memory Efficiency of Data Structures","text":"

    In terms of memory space utilization, arrays and linked lists have their advantages and limitations.

    On one hand, memory is limited and cannot be shared by multiple programs, so we hope that data structures can use space as efficiently as possible. The elements of an array are tightly packed without extra space for storing references (pointers) between linked list nodes, making them more space-efficient. However, arrays require allocating sufficient continuous memory space at once, which may lead to memory waste, and array expansion also requires additional time and space costs. In contrast, linked lists allocate and reclaim memory dynamically on a per-node basis, providing greater flexibility.

    On the other hand, during program execution, as memory is repeatedly allocated and released, the degree of fragmentation of free memory becomes higher, leading to reduced memory utilization efficiency. Arrays, due to their continuous storage method, are relatively less likely to cause memory fragmentation. In contrast, the elements of a linked list are dispersedly stored, and frequent insertion and deletion operations make memory fragmentation more likely.

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443-cache-efficiency-of-data-structures","title":"4.4.3 \u00a0 Cache Efficiency of Data Structures","text":"

    Although caches are much smaller in space capacity than memory, they are much faster and play a crucial role in program execution speed. Since the cache's capacity is limited and can only store a small part of frequently accessed data, when the CPU tries to access data not in the cache, a \"cache miss\" occurs, forcing the CPU to load the needed data from slower memory.

    Clearly, the fewer the cache misses, the higher the CPU's data read-write efficiency, and the better the program performance. The proportion of successful data retrieval from the cache by the CPU is called the \"cache hit rate,\" a metric often used to measure cache efficiency.

    To achieve higher efficiency, caches adopt the following data loading mechanisms.

    • Cache Lines: Caches don't store and load data byte by byte but in units of cache lines. Compared to byte-by-byte transfer, the transmission of cache lines is more efficient.
    • Prefetch Mechanism: Processors try to predict data access patterns (such as sequential access, fixed stride jumping access, etc.) and load data into the cache according to specific patterns to improve the hit rate.
    • Spatial Locality: If data is accessed, data nearby is likely to be accessed in the near future. Therefore, when loading certain data, the cache also loads nearby data to improve the hit rate.
    • Temporal Locality: If data is accessed, it's likely to be accessed again in the near future. Caches use this principle to retain recently accessed data to improve the hit rate.

    In fact, arrays and linked lists have different cache utilization efficiencies, mainly reflected in the following aspects.

    • Occupied Space: Linked list elements occupy more space than array elements, resulting in less effective data volume in the cache.
    • Cache Lines: Linked list data is scattered throughout memory, and since caches load \"by line,\" the proportion of loading invalid data is higher.
    • Prefetch Mechanism: The data access pattern of arrays is more \"predictable\" than that of linked lists, meaning the system is more likely to guess which data will be loaded next.
    • Spatial Locality: Arrays are stored in concentrated memory spaces, so the data near the loaded data is more likely to be accessed next.

    Overall, arrays have a higher cache hit rate and are generally more efficient in operation than linked lists. This makes data structures based on arrays more popular in solving algorithmic problems.

    It should be noted that high cache efficiency does not mean that arrays are always better than linked lists. Which data structure to choose in actual applications should be based on specific requirements. For example, both arrays and linked lists can implement the \"stack\" data structure (which will be detailed in the next chapter), but they are suitable for different scenarios.

    • In algorithm problems, we tend to choose stacks based on arrays because they provide higher operational efficiency and random access capabilities, with the only cost being the need to pre-allocate a certain amount of memory space for the array.
    • If the data volume is very large, highly dynamic, and the expected size of the stack is difficult to estimate, then a stack based on a linked list is more appropriate. Linked lists can disperse a large amount of data in different parts of the memory and avoid the additional overhead of array expansion.
    "},{"location":"chapter_array_and_linkedlist/summary/","title":"4.5 \u00a0 Summary","text":""},{"location":"chapter_array_and_linkedlist/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"
    • Arrays and linked lists are two basic data structures, representing two storage methods in computer memory: contiguous space storage and non-contiguous space storage. Their characteristics complement each other.
    • Arrays support random access and use less memory; however, they are inefficient in inserting and deleting elements and have a fixed length after initialization.
    • Linked lists implement efficient node insertion and deletion through changing references (pointers) and can flexibly adjust their length; however, they have lower node access efficiency and consume more memory.
    • Common types of linked lists include singly linked lists, circular linked lists, and doubly linked lists, each with its own application scenarios.
    • Lists are ordered collections of elements that support addition, deletion, and modification, typically implemented based on dynamic arrays, retaining the advantages of arrays while allowing flexible length adjustment.
    • The advent of lists significantly enhanced the practicality of arrays but may lead to some memory space wastage.
    • During program execution, data is mainly stored in memory. Arrays provide higher memory space efficiency, while linked lists are more flexible in memory usage.
    • Caches provide fast data access to CPUs through mechanisms like cache lines, prefetching, spatial locality, and temporal locality, significantly enhancing program execution efficiency.
    • Due to higher cache hit rates, arrays are generally more efficient than linked lists. When choosing a data structure, the appropriate choice should be made based on specific needs and scenarios.
    "},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Does storing arrays on the stack versus the heap affect time and space efficiency?

    Arrays stored on both the stack and heap are stored in contiguous memory spaces, and data operation efficiency is essentially the same. However, stacks and heaps have their own characteristics, leading to the following differences.

    1. Allocation and release efficiency: The stack is a smaller memory block, allocated automatically by the compiler; the heap memory is relatively larger and can be dynamically allocated in the code, more prone to fragmentation. Therefore, allocation and release operations on the heap are generally slower than on the stack.
    2. Size limitation: Stack memory is relatively small, while the heap size is generally limited by available memory. Therefore, the heap is more suitable for storing large arrays.
    3. Flexibility: The size of arrays on the stack needs to be determined at compile-time, while the size of arrays on the heap can be dynamically determined at runtime.

    Q: Why do arrays require elements of the same type, while linked lists do not emphasize same-type elements?

    Linked lists consist of nodes connected by references (pointers), and each node can store data of different types, such as int, double, string, object, etc.

    In contrast, array elements must be of the same type, allowing the calculation of offsets to access the corresponding element positions. For example, an array containing both int and long types, with single elements occupying 4 bytes and 8 bytes respectively, cannot use the following formula to calculate offsets, as the array contains elements of two different lengths.

    # Element memory address = Array memory address + Element length * Element index\n

    Q: After deleting a node, is it necessary to set P.next to None?

    Not modifying P.next is also acceptable. From the perspective of the linked list, traversing from the head node to the tail node will no longer encounter P. This means that node P has been effectively removed from the list, and where P points no longer affects the list.

    From a garbage collection perspective, for languages with automatic garbage collection mechanisms like Java, Python, and Go, whether node P is collected depends on whether there are still references pointing to it, not on the value of P.next. In languages like C and C++, we need to manually free the node's memory.

    Q: In linked lists, the time complexity for insertion and deletion operations is O(1). But searching for the element before insertion or deletion takes O(n) time, so why isn't the time complexity O(n)?

    If an element is searched first and then deleted, the time complexity is indeed O(n). However, the O(1) advantage of linked lists in insertion and deletion can be realized in other applications. For example, in the implementation of double-ended queues using linked lists, we maintain pointers always pointing to the head and tail nodes, making each insertion and deletion operation O(1).

    Q: In the image \"Linked List Definition and Storage Method\", do the light blue storage nodes occupy a single memory address, or do they share half with the node value?

    The diagram is just a qualitative representation; quantitative analysis depends on specific situations.

    • Different types of node values occupy different amounts of space, such as int, long, double, and object instances.
    • The memory space occupied by pointer variables depends on the operating system and compilation environment used, usually 8 bytes or 4 bytes.

    Q: Is adding elements to the end of a list always O(1)?

    If adding an element exceeds the list length, the list needs to be expanded first. The system will request a new memory block and move all elements of the original list over, in which case the time complexity becomes O(n).

    Q: The statement \"The emergence of lists greatly improves the practicality of arrays, but may lead to some memory space wastage\" - does this refer to the memory occupied by additional variables like capacity, length, and expansion multiplier?

    The space wastage here mainly refers to two aspects: on the one hand, lists are set with an initial length, which we may not always need; on the other hand, to prevent frequent expansion, expansion usually multiplies by a coefficient, such as \\(\\times 1.5\\). This results in many empty slots, which we typically cannot fully fill.

    Q: In Python, after initializing n = [1, 2, 3], the addresses of these 3 elements are contiguous, but initializing m = [2, 1, 3] shows that each element's id is not consecutive but identical to those in n. If the addresses of these elements are not contiguous, is m still an array?

    If we replace list elements with linked list nodes n = [n1, n2, n3, n4, n5], these 5 node objects are also typically dispersed throughout memory. However, given a list index, we can still access the node's memory address in O(1) time, thereby accessing the corresponding node. This is because the array stores references to the nodes, not the nodes themselves.

    Unlike many languages, in Python, numbers are also wrapped as objects, and lists store references to these numbers, not the numbers themselves. Therefore, we find that the same number in two arrays has the same id, and these numbers' memory addresses need not be contiguous.

    Q: The std::list in C++ STL has already implemented a doubly linked list, but it seems that some algorithm books don't directly use it. Is there any limitation?

    On the one hand, we often prefer to use arrays to implement algorithms, only using linked lists when necessary, mainly for two reasons.

    • Space overhead: Since each element requires two additional pointers (one for the previous element and one for the next), std::list usually occupies more space than std::vector.
    • Cache unfriendly: As the data is not stored continuously, std::list has a lower cache utilization rate. Generally, std::vector performs better.

    On the other hand, linked lists are primarily necessary for binary trees and graphs. Stacks and queues are often implemented using the programming language's stack and queue classes, rather than linked lists.

    Q: Does initializing a list res = [0] * self.size() result in each element of res referencing the same address?

    No. However, this issue arises with two-dimensional arrays, for example, initializing a two-dimensional list res = [[0] * self.size()] would reference the same list [0] multiple times.

    Q: In deleting a node, is it necessary to break the reference to its successor node?

    From the perspective of data structures and algorithms (problem-solving), it's okay not to break the link, as long as the program's logic is correct. From the perspective of standard libraries, breaking the link is safer and more logically clear. If the link is not broken, and the deleted node is not properly recycled, it could affect the recycling of the successor node's memory.

    "},{"location":"chapter_computational_complexity/","title":"Chapter 2. \u00a0 Complexity Analysis","text":"

    Abstract

    Complexity analysis is like a space-time navigator in the vast universe of algorithms.

    It guides us in exploring deeper within the the dimensions of time and space, seeking more elegant solutions.

    "},{"location":"chapter_computational_complexity/#chapter-contents","title":"Chapter Contents","text":"
    • 2.1 \u00a0 Algorithm Efficiency Assessment
    • 2.2 \u00a0 Iteration and Recursion
    • 2.3 \u00a0 Time Complexity
    • 2.4 \u00a0 Space Complexity
    • 2.5 \u00a0 Summary
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/","title":"2.2 \u00a0 Iteration and Recursion","text":"

    In algorithms, the repeated execution of a task is quite common and is closely related to the analysis of complexity. Therefore, before delving into the concepts of time complexity and space complexity, let's first explore how to implement repetitive tasks in programming. This involves understanding two fundamental programming control structures: iteration and recursion.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#221-iteration","title":"2.2.1 \u00a0 Iteration","text":"

    \"Iteration\" is a control structure for repeatedly performing a task. In iteration, a program repeats a block of code as long as a certain condition is met until this condition is no longer satisfied.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for-loops","title":"1. \u00a0 For Loops","text":"

    The for loop is one of the most common forms of iteration, and it's particularly suitable when the number of iterations is known in advance.

    The following function uses a for loop to perform a summation of \\(1 + 2 + \\dots + n\\), with the sum being stored in the variable res. It's important to note that in Python, range(a, b) creates an interval that is inclusive of a but exclusive of b, meaning it iterates over the range from \\(a\\) up to \\(b\u22121\\).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def for_loop(n: int) -> int:\n    \"\"\"for \u5faa\u73af\"\"\"\n    res = 0\n    # \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n
    iteration.cpp
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.java
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.cs
    /* for \u5faa\u73af */\nint ForLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.go
    /* for \u5faa\u73af */\nfunc forLoop(n int) int {\n    res := 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i := 1; i <= n; i++ {\n        res += i\n    }\n    return res\n}\n
    iteration.swift
    /* for \u5faa\u73af */\nfunc forLoop(n: Int) -> Int {\n    var res = 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n
    iteration.js
    /* for \u5faa\u73af */\nfunction forLoop(n) {\n    let res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.ts
    /* for \u5faa\u73af */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.dart
    /* for \u5faa\u73af */\nint forLoop(int n) {\n  int res = 0;\n  // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n  for (int i = 1; i <= n; i++) {\n    res += i;\n  }\n  return res;\n}\n
    iteration.rs
    /* for \u5faa\u73af */\nfn for_loop(n: i32) -> i32 {\n    let mut res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n
    iteration.c
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.kt
    /* for \u5faa\u73af */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{for_loop}\n
    iteration.zig
    // for \u5faa\u73af\nfn forLoop(n: usize) i32 {\n    var res: i32 = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (1..n+1) |i| {\n        res = res + @as(i32, @intCast(i));\n    }\n    return res;\n} \n
    Code Visualization

    Full Screen >

    The flowchart below represents this sum function.

    Figure 2-1 \u00a0 Flowchart of the Sum Function

    The number of operations in this summation function is proportional to the size of the input data \\(n\\), or in other words, it has a \"linear relationship.\" This \"linear relationship\" is what time complexity describes. This topic will be discussed in more detail in the next section.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while-loops","title":"2. \u00a0 While Loops","text":"

    Similar to for loops, while loops are another approach for implementing iteration. In a while loop, the program checks a condition at the beginning of each iteration; if the condition is true, the execution continues, otherwise, the loop ends.

    Below we use a while loop to implement the sum \\(1 + 2 + \\dots + n\\).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def while_loop(n: int) -> int:\n    \"\"\"while \u5faa\u73af\"\"\"\n    res = 0\n    i = 1  # \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    # \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n:\n        res += i\n        i += 1  # \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    return res\n
    iteration.cpp
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.java
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.cs
    /* while \u5faa\u73af */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i += 1; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.go
    /* while \u5faa\u73af */\nfunc whileLoop(n int) int {\n    res := 0\n    // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    i := 1\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n    }\n    return res\n}\n
    iteration.swift
    /* while \u5faa\u73af */\nfunc whileLoop(n: Int) -> Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n {\n        res += i\n        i += 1 // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res\n}\n
    iteration.js
    /* while \u5faa\u73af */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.ts
    /* while \u5faa\u73af */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.dart
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n  // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n  while (i <= n) {\n    res += i;\n    i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n  }\n  return res;\n}\n
    iteration.rs
    /* while \u5faa\u73af */\nfn while_loop(n: i32) -> i32 {\n    let mut res = 0;\n    let mut i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n {\n        res += i;\n        i += 1; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    res\n}\n
    iteration.c
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.kt
    /* while \u5faa\u73af */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i\n        i++ // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{while_loop}\n
    iteration.zig
    // while \u5faa\u73af\nfn whileLoop(n: i32) i32 {\n    var res: i32 = 0;\n    var i: i32 = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += @intCast(i);\n        i += 1;\n    }\n    return res;\n}\n
    Code Visualization

    Full Screen >

    While loops provide more flexibility than for loops, especially since they allow for custom initialization and modification of the condition variable at each step.

    For example, in the following code, the condition variable \\(i\\) is updated twice each round, which would be inconvenient to implement with a for loop.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def while_loop_ii(n: int) -> int:\n    \"\"\"while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09\"\"\"\n    res = 0\n    i = 1  # \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    # \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n:\n        res += i\n        # \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1\n        i *= 2\n    return res\n
    iteration.cpp
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.java
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.cs
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n
    iteration.go
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunc whileLoopII(n int) int {\n    res := 0\n    // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    i := 1\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    for i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n        i *= 2\n    }\n    return res\n}\n
    iteration.swift
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunc whileLoopII(n: Int) -> Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1\n        i *= 2\n    }\n    return res\n}\n
    iteration.js
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.ts
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.dart
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n  // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n  while (i <= n) {\n    res += i;\n    // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n
    iteration.rs
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfn while_loop_ii(n: i32) -> i32 {\n    let mut res = 0;\n    let mut i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n
    iteration.c
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.kt
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n        i *= 2\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{while_loop_ii}\n
    iteration.zig
    //  while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09\nfn whileLoopII(n: i32) i32 {\n    var res: i32 = 0;\n    var i: i32 = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += @intCast(i);\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1;\n        i *= 2;\n    }\n    return res;\n}\n
    Code Visualization

    Full Screen >

    Overall, for loops are more concise, while while loops are more flexible. Both can implement iterative structures. Which one to use should be determined based on the specific requirements of the problem.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#3-nested-loops","title":"3. \u00a0 Nested Loops","text":"

    We can nest one loop structure within another. Below is an example using for loops:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def nested_for_loop(n: int) -> str:\n    \"\"\"\u53cc\u5c42 for \u5faa\u73af\"\"\"\n    res = \"\"\n    # \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n
    iteration.cpp
    /* \u53cc\u5c42 for \u5faa\u73af */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; ++i) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; ++j) {\n            res << \"(\" << i << \", \" << j << \"), \";\n        }\n    }\n    return res.str();\n}\n
    iteration.java
    /* \u53cc\u5c42 for \u5faa\u73af */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n
    iteration.cs
    /* \u53cc\u5c42 for \u5faa\u73af */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n
    iteration.go
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i := 1; i <= n; i++ {\n        for j := 1; j <= n; j++ {\n            // \u5faa\u73af j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n
    iteration.swift
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunc nestedForLoop(n: Int) -> String {\n    var res = \"\"\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n
    iteration.js
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunction nestedForLoop(n) {\n    let res = '';\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (let j = 1; j <= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n
    iteration.ts
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (let j = 1; j <= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n
    iteration.dart
    /* \u53cc\u5c42 for \u5faa\u73af */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // \u5faa\u73af i = 1, 2, ..., n-1, n\n  for (int i = 1; i <= n; i++) {\n    // \u5faa\u73af j = 1, 2, ..., n-1, n\n    for (int j = 1; j <= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n
    iteration.rs
    /* \u53cc\u5c42 for \u5faa\u73af */\nfn nested_for_loop(n: i32) -> String {\n    let mut res = vec![];\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n
    iteration.c
    /* \u53cc\u5c42 for \u5faa\u73af */\nchar *nestedForLoop(int n) {\n    // n * n \u4e3a\u5bf9\u5e94\u70b9\u6570\u91cf\uff0c\"(i, j), \" \u5bf9\u5e94\u5b57\u7b26\u4e32\u957f\u6700\u5927\u4e3a 6+10*2\uff0c\u52a0\u4e0a\u6700\u540e\u4e00\u4e2a\u7a7a\u5b57\u7b26 \\0 \u7684\u989d\u5916\u7a7a\u95f4\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n
    iteration.kt
    /* \u53cc\u5c42 for \u5faa\u73af */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n
    iteration.rb
    [class]{}-[func]{nested_for_loop}\n
    iteration.zig
    // \u53cc\u5c42 for \u5faa\u73af\nfn nestedForLoop(allocator: Allocator, n: usize) ![]const u8 {\n    var res = std.ArrayList(u8).init(allocator);\n    defer res.deinit();\n    var buffer: [20]u8 = undefined;\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (1..n+1) |i| {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (1..n+1) |j| {\n            var _str = try std.fmt.bufPrint(&buffer, \"({d}, {d}), \", .{i, j});\n            try res.appendSlice(_str);\n        }\n    }\n    return res.toOwnedSlice();\n}\n
    Code Visualization

    Full Screen >

    The flowchart below represents this nested loop.

    Figure 2-2 \u00a0 Flowchart of the Nested Loop

    In such cases, the number of operations of the function is proportional to \\(n^2\\), meaning the algorithm's runtime and the size of the input data \\(n\\) has a 'quadratic relationship.'

    We can further increase the complexity by adding more nested loops, each level of nesting effectively \"increasing the dimension,\" which raises the time complexity to \"cubic,\" \"quartic,\" and so on.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#222-recursion","title":"2.2.2 \u00a0 Recursion","text":"

    \"Recursion\" is an algorithmic strategy where a function solves a problem by calling itself. It primarily involves two phases:

    1. Calling: This is where the program repeatedly calls itself, often with progressively smaller or simpler arguments, moving towards the \"termination condition.\"
    2. Returning: Upon triggering the \"termination condition,\" the program begins to return from the deepest recursive function, aggregating the results of each layer.

    From an implementation perspective, recursive code mainly includes three elements.

    1. Termination Condition: Determines when to switch from \"calling\" to \"returning.\"
    2. Recursive Call: Corresponds to \"calling,\" where the function calls itself, usually with smaller or more simplified parameters.
    3. Return Result: Corresponds to \"returning,\" where the result of the current recursion level is returned to the previous layer.

    Observe the following code, where simply calling the function recur(n) can compute the sum of \\(1 + 2 + \\dots + n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def recur(n: int) -> int:\n    \"\"\"\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if n == 1:\n        return 1\n    # \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    res = recur(n - 1)\n    # \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n
    recursion.cpp
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.java
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.cs
    /* \u9012\u5f52 */\nint Recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = Recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.go
    /* \u9012\u5f52 */\nfunc recur(n int) int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    res := recur(n - 1)\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.swift
    /* \u9012\u5f52 */\nfunc recur(n: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    let res = recur(n: n - 1)\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.js
    /* \u9012\u5f52 */\nfunction recur(n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 1) return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    const res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.ts
    /* \u9012\u5f52 */\nfunction recur(n: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 1) return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    const res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.dart
    /* \u9012\u5f52 */\nint recur(int n) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (n == 1) return 1;\n  // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n  int res = recur(n - 1);\n  // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n  return n + res;\n}\n
    recursion.rs
    /* \u9012\u5f52 */\nfn recur(n: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1;\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    let res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    n + res\n}\n
    recursion.c
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.kt
    /* \u9012\u5f52 */\nfun recur(n: Int): Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1\n    // \u9012: \u9012\u5f52\u8c03\u7528\n    val res = recur(n - 1)\n    // \u5f52: \u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.rb
    [class]{}-[func]{recur}\n
    recursion.zig
    // \u9012\u5f52\u51fd\u6570\nfn recur(n: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1) {\n        return 1;\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    var res: i32 = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    Code Visualization

    Full Screen >

    The Figure 2-3 shows the recursive process of this function.

    Figure 2-3 \u00a0 Recursive Process of the Sum Function

    Although iteration and recursion can achieve the same results from a computational standpoint, they represent two entirely different paradigms of thinking and problem-solving.

    • Iteration: Solves problems \"from the bottom up.\" It starts with the most basic steps, and then repeatedly adds or accumulates these steps until the task is complete.
    • Recursion: Solves problems \"from the top down.\" It breaks down the original problem into smaller sub-problems, each of which has the same form as the original problem. These sub-problems are then further decomposed into even smaller sub-problems, stopping at the base case whose solution is known.

    Let's take the earlier example of the summation function, defined as \\(f(n) = 1 + 2 + \\dots + n\\).

    • Iteration: In this approach, we simulate the summation process within a loop. Starting from \\(1\\) and traversing to \\(n\\), we perform the summation operation in each iteration to eventually compute \\(f(n)\\).
    • Recursion: Here, the problem is broken down into a sub-problem: \\(f(n) = n + f(n-1)\\). This decomposition continues recursively until reaching the base case, \\(f(1) = 1\\), at which point the recursion terminates.
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-call-stack","title":"1. \u00a0 Call Stack","text":"

    Every time a recursive function calls itself, the system allocates memory for the newly initiated function to store local variables, the return address, and other relevant information. This leads to two primary outcomes.

    • The function's context data is stored in a memory area called \"stack frame space\" and is only released after the function returns. Therefore, recursion generally consumes more memory space than iteration.
    • Recursive calls introduce additional overhead. Hence, recursion is usually less time-efficient than loops.

    As shown in the Figure 2-4 , there are \\(n\\) unreturned recursive functions before triggering the termination condition, indicating a recursion depth of \\(n\\).

    Figure 2-4 \u00a0 Recursion Call Depth

    In practice, the depth of recursion allowed by programming languages is usually limited, and excessively deep recursion can lead to stack overflow errors.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-tail-recursion","title":"2. \u00a0 Tail Recursion","text":"

    Interestingly, if a function performs its recursive call as the very last step before returning, it can be optimized by the compiler or interpreter to be as space-efficient as iteration. This scenario is known as \"tail recursion.\"

    • Regular Recursion: In standard recursion, when the function returns to the previous level, it continues to execute more code, requiring the system to save the context of the previous call.
    • Tail Recursion: Here, the recursive call is the final operation before the function returns. This means that upon returning to the previous level, no further actions are needed, so the system does not need to save the context of the previous level.

    For example, in calculating \\(1 + 2 + \\dots + n\\), we can make the result variable res a parameter of the function, thereby achieving tail recursion:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def tail_recur(n, res):\n    \"\"\"\u5c3e\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if n == 0:\n        return res\n    # \u5c3e\u9012\u5f52\u8c03\u7528\n    return tail_recur(n - 1, res + n)\n
    recursion.cpp
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.java
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.cs
    /* \u5c3e\u9012\u5f52 */\nint TailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return TailRecur(n - 1, res + n);\n}\n
    recursion.go
    /* \u5c3e\u9012\u5f52 */\nfunc tailRecur(n int, res int) int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n-1, res+n)\n}\n
    recursion.swift
    /* \u5c3e\u9012\u5f52 */\nfunc tailRecur(n: Int, res: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n: n - 1, res: res + n)\n}\n
    recursion.js
    /* \u5c3e\u9012\u5f52 */\nfunction tailRecur(n, res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 0) return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.ts
    /* \u5c3e\u9012\u5f52 */\nfunction tailRecur(n: number, res: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 0) return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.dart
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (n == 0) return res;\n  // \u5c3e\u9012\u5f52\u8c03\u7528\n  return tailRecur(n - 1, res + n);\n}\n
    recursion.rs
    /* \u5c3e\u9012\u5f52 */\nfn tail_recur(n: i32, res: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res;\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    tail_recur(n - 1, res + n)\n}\n
    recursion.c
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.kt
    /* \u5c3e\u9012\u5f52 */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // \u6dfb\u52a0 tailrec \u5173\u952e\u8bcd\uff0c\u4ee5\u5f00\u542f\u5c3e\u9012\u5f52\u4f18\u5316\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n)\n}\n
    recursion.rb
    [class]{}-[func]{tail_recur}\n
    recursion.zig
    // \u5c3e\u9012\u5f52\u51fd\u6570\nfn tailRecur(n: i32, res: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0) {\n        return res;\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    Code Visualization

    Full Screen >

    The execution process of tail recursion is shown in the following figure. Comparing regular recursion and tail recursion, the point of the summation operation is different.

    • Regular Recursion: The summation operation occurs during the \"returning\" phase, requiring another summation after each layer returns.
    • Tail Recursion: The summation operation occurs during the \"calling\" phase, and the \"returning\" phase only involves returning through each layer.

    Figure 2-5 \u00a0 Tail Recursion Process

    Tip

    Note that many compilers or interpreters do not support tail recursion optimization. For example, Python does not support tail recursion optimization by default, so even if the function is in the form of tail recursion, it may still encounter stack overflow issues.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#3-recursion-tree","title":"3. \u00a0 Recursion Tree","text":"

    When dealing with algorithms related to \"divide and conquer\", recursion often offers a more intuitive approach and more readable code than iteration. Take the \"Fibonacci sequence\" as an example.

    Question

    Given a Fibonacci sequence \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\), find the \\(n\\)th number in the sequence.

    Let the \\(n\\)th number of the Fibonacci sequence be \\(f(n)\\), it's easy to deduce two conclusions:

    • The first two numbers of the sequence are \\(f(1) = 0\\) and \\(f(2) = 1\\).
    • Each number in the sequence is the sum of the two preceding ones, that is, \\(f(n) = f(n - 1) + f(n - 2)\\).

    Using the recursive relation, and considering the first two numbers as termination conditions, we can write the recursive code. Calling fib(n) will yield the \\(n\\)th number of the Fibonacci sequence:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def fib(n: int) -> int:\n    \"\"\"\u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n
    recursion.cpp
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.java
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.cs
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint Fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.go
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunc fib(n int) int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.swift
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunc fib(n: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.js
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunction fib(n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.ts
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunction fib(n: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.dart
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n  // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // \u8fd4\u56de\u7ed3\u679c f(n)\n  return res;\n}\n
    recursion.rs
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfn fib(n: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c\n    res\n}\n
    recursion.c
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.kt
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfun fib(n: Int): Int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.rb
    [class]{}-[func]{fib}\n
    recursion.zig
    // \u6590\u6ce2\u90a3\u5951\u6570\u5217\nfn fib(n: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 or n == 2) {\n        return n - 1;\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    var res: i32 = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    Code Visualization

    Full Screen >

    Observing the above code, we see that it recursively calls two functions within itself, meaning that one call generates two branching calls. As illustrated below, this continuous recursive calling eventually creates a \"recursion tree\" with a depth of \\(n\\).

    Figure 2-6 \u00a0 Fibonacci Sequence Recursion Tree

    Fundamentally, recursion embodies the paradigm of \"breaking down a problem into smaller sub-problems.\" This divide-and-conquer strategy is crucial.

    • From an algorithmic perspective, many important strategies like searching, sorting, backtracking, divide-and-conquer, and dynamic programming directly or indirectly use this way of thinking.
    • From a data structure perspective, recursion is naturally suited for dealing with linked lists, trees, and graphs, as they are well suited for analysis using the divide-and-conquer approach.
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#223-comparison","title":"2.2.3 \u00a0 Comparison","text":"

    Summarizing the above content, the following table shows the differences between iteration and recursion in terms of implementation, performance, and applicability.

    Table: Comparison of Iteration and Recursion Characteristics

    Iteration Recursion Approach Loop structure Function calls itself Time Efficiency Generally higher efficiency, no function call overhead Each function call generates overhead Memory Usage Typically uses a fixed size of memory space Accumulative function calls can use a substantial amount of stack frame space Suitable Problems Suitable for simple loop tasks, intuitive and readable code Suitable for problem decomposition, like trees, graphs, divide-and-conquer, backtracking, etc., concise and clear code structure

    Tip

    If you find the following content difficult to understand, consider revisiting it after reading the \"Stack\" chapter.

    So, what is the intrinsic connection between iteration and recursion? Taking the above recursive function as an example, the summation operation occurs during the recursion's \"return\" phase. This means that the initially called function is the last to complete its summation operation, mirroring the \"last in, first out\" principle of a stack.

    Recursive terms like \"call stack\" and \"stack frame space\" hint at the close relationship between recursion and stacks.

    1. Calling: When a function is called, the system allocates a new stack frame on the \"call stack\" for that function, storing local variables, parameters, return addresses, and other data.
    2. Returning: When a function completes execution and returns, the corresponding stack frame is removed from the \"call stack,\" restoring the execution environment of the previous function.

    Therefore, we can use an explicit stack to simulate the behavior of the call stack, thus transforming recursion into an iterative form:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def for_loop_recur(n: int) -> int:\n    \"\"\"\u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52\"\"\"\n    # \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack = []\n    res = 0\n    # \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in range(n, 0, -1):\n        # \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.append(i)\n    # \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while stack:\n        # \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n
    recursion.cpp
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack<int> stack;\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (!stack.empty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.java
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    Stack<Integer> stack = new Stack<>();\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (!stack.isEmpty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.cs
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint ForLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    Stack<int> stack = new();\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.Push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.Count > 0) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.go
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunc forLoopRecur(n int) int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack := list.New()\n    res := 0\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i := n; i > 0; i-- {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.PushBack(i)\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    for stack.Len() != 0 {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.swift
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunc forLoopRecur(n: Int) -> Int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    var stack: [Int] = []\n    var res = 0\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in (1 ... n).reversed() {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.append(i)\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while !stack.isEmpty {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.js
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunction forLoopRecur(n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    const stack = [];\n    let res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (let i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.length) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.ts
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunction forLoopRecur(n: number): number {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808 \n    const stack: number[] = [];\n    let res: number = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (let i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.length) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.dart
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n  // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n  List<int> stack = [];\n  int res = 0;\n  // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n  for (int i = n; i > 0; i--) {\n    // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n    stack.add(i);\n  }\n  // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n  while (!stack.isEmpty) {\n    // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n
    recursion.rs
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfn for_loop_recur(n: i32) -> i32 {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in (1..=n).rev() {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while !stack.is_empty() {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n
    recursion.c
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    int stack[1000]; // \u501f\u52a9\u4e00\u4e2a\u5927\u6570\u7ec4\u6765\u6a21\u62df\u6808\n    int top = -1;    // \u6808\u9876\u7d22\u5f15\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack[1 + top++] = i;\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (top >= 0) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.kt
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfun forLoopRecur(n: Int): Int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    val stack = Stack<Int>()\n    var res = 0\n    // \u9012: \u9012\u5f52\u8c03\u7528\n    for (i in n downTo 0) {\n        stack.push(i)\n    }\n    // \u5f52: \u8fd4\u56de\u7ed3\u679c\n    while (stack.isNotEmpty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.rb
    [class]{}-[func]{for_loop_recur}\n
    recursion.zig
    // \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52\nfn forLoopRecur(comptime n: i32) i32 {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    var stack: [n]i32 = undefined;\n    var res: i32 = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    var i: usize = n;\n    while (i > 0) {\n        stack[i - 1] = @intCast(i);\n        i -= 1;\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    var index: usize = n;\n    while (index > 0) {\n        index -= 1;\n        res += stack[index];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    Code Visualization

    Full Screen >

    Observing the above code, when recursion is transformed into iteration, the code becomes more complex. Although iteration and recursion can often be transformed into each other, it's not always advisable to do so for two reasons:

    • The transformed code may become more challenging to understand and less readable.
    • For some complex problems, simulating the behavior of the system's call stack can be quite challenging.

    In conclusion, whether to choose iteration or recursion depends on the specific nature of the problem. In programming practice, it's crucial to weigh the pros and cons of both and choose the most suitable approach for the situation at hand.

    "},{"location":"chapter_computational_complexity/performance_evaluation/","title":"2.1 \u00a0 Algorithm Efficiency Assessment","text":"

    In algorithm design, we pursue the following two objectives in sequence.

    1. Finding a Solution to the Problem: The algorithm should reliably find the correct solution within the stipulated range of inputs.
    2. Seeking the Optimal Solution: For the same problem, multiple solutions might exist, and we aim to find the most efficient algorithm possible.

    In other words, under the premise of being able to solve the problem, algorithm efficiency has become the main criterion for evaluating the merits of an algorithm, which includes the following two dimensions.

    • Time Efficiency: The speed at which an algorithm runs.
    • Space Efficiency: The size of the memory space occupied by an algorithm.

    In short, our goal is to design data structures and algorithms that are both fast and memory-efficient. Effectively assessing algorithm efficiency is crucial because only then can we compare various algorithms and guide the process of algorithm design and optimization.

    There are mainly two methods of efficiency assessment: actual testing and theoretical estimation.

    "},{"location":"chapter_computational_complexity/performance_evaluation/#211-actual-testing","title":"2.1.1 \u00a0 Actual Testing","text":"

    Suppose we have algorithms A and B, both capable of solving the same problem, and we need to compare their efficiencies. The most direct method is to use a computer to run these two algorithms and monitor and record their runtime and memory usage. This assessment method reflects the actual situation but has significant limitations.

    On one hand, it's difficult to eliminate interference from the testing environment. Hardware configurations can affect algorithm performance. For example, algorithm A might run faster than B on one computer, but the opposite result may occur on another computer with different configurations. This means we would need to test on a variety of machines to calculate average efficiency, which is impractical.

    On the other hand, conducting a full test is very resource-intensive. As the volume of input data changes, the efficiency of the algorithms may vary. For example, with smaller data volumes, algorithm A might run faster than B, but the opposite might be true with larger data volumes. Therefore, to draw convincing conclusions, we need to test a wide range of input data sizes, which requires significant computational resources.

    "},{"location":"chapter_computational_complexity/performance_evaluation/#212-theoretical-estimation","title":"2.1.2 \u00a0 Theoretical Estimation","text":"

    Due to the significant limitations of actual testing, we can consider evaluating algorithm efficiency solely through calculations. This estimation method is known as \"asymptotic complexity analysis,\" or simply \"complexity analysis.\"

    Complexity analysis reflects the relationship between the time and space resources required for algorithm execution and the size of the input data. It describes the trend of growth in the time and space required by the algorithm as the size of the input data increases. This definition might sound complex, but we can break it down into three key points to understand it better.

    • \"Time and space resources\" correspond to \"time complexity\" and \"space complexity,\" respectively.
    • \"As the size of input data increases\" means that complexity reflects the relationship between algorithm efficiency and the volume of input data.
    • \"The trend of growth in time and space\" indicates that complexity analysis focuses not on the specific values of runtime or space occupied but on the \"rate\" at which time or space grows.

    Complexity analysis overcomes the disadvantages of actual testing methods, reflected in the following aspects:

    • It is independent of the testing environment and applicable to all operating platforms.
    • It can reflect algorithm efficiency under different data volumes, especially in the performance of algorithms with large data volumes.

    Tip

    If you're still confused about the concept of complexity, don't worry. We will introduce it in detail in subsequent chapters.

    Complexity analysis provides us with a \"ruler\" to measure the time and space resources needed to execute an algorithm and compare the efficiency between different algorithms.

    Complexity is a mathematical concept and may be abstract and challenging for beginners. From this perspective, complexity analysis might not be the best content to introduce first. However, when discussing the characteristics of a particular data structure or algorithm, it's hard to avoid analyzing its speed and space usage.

    In summary, it's recommended that you establish a preliminary understanding of complexity analysis before diving deep into data structures and algorithms, so that you can carry out simple complexity analyses of algorithms.

    "},{"location":"chapter_computational_complexity/space_complexity/","title":"2.4 \u00a0 Space Complexity","text":"

    \"Space complexity\" is used to measure the growth trend of the memory space occupied by an algorithm as the amount of data increases. This concept is very similar to time complexity, except that \"running time\" is replaced with \"occupied memory space\".

    "},{"location":"chapter_computational_complexity/space_complexity/#241-space-related-to-algorithms","title":"2.4.1 \u00a0 Space Related to Algorithms","text":"

    The memory space used by an algorithm during its execution mainly includes the following types.

    • Input Space: Used to store the input data of the algorithm.
    • Temporary Space: Used to store variables, objects, function contexts, and other data during the algorithm's execution.
    • Output Space: Used to store the output data of the algorithm.

    Generally, the scope of space complexity statistics includes both \"Temporary Space\" and \"Output Space\".

    Temporary space can be further divided into three parts.

    • Temporary Data: Used to save various constants, variables, objects, etc., during the algorithm's execution.
    • Stack Frame Space: Used to save the context data of the called function. The system creates a stack frame at the top of the stack each time a function is called, and the stack frame space is released after the function returns.
    • Instruction Space: Used to store compiled program instructions, which are usually negligible in actual statistics.

    When analyzing the space complexity of a program, we typically count the Temporary Data, Stack Frame Space, and Output Data, as shown in the Figure 2-15 .

    Figure 2-15 \u00a0 Space Types Used in Algorithms

    The relevant code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    class Node:\n    \"\"\"Classes\"\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x               # node value\n        self.next: Node | None = None   # reference to the next node\n\ndef function() -> int:\n    \"\"\"\"Functions\"\"\"\"\"\n    # Perform certain operations...\n    return 0\n\ndef algorithm(n) -> int:    # input data\n    A = 0                   # temporary data (constant, usually in uppercase)\n    b = 0                   # temporary data (variable)\n    node = Node(0)          # temporary data (object)\n    c = function()          # Stack frame space (call function)\n    return A + b + c        # output data\n
    /* Structures */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* Functions */\nint func() {\n    // Perform certain operations...\n    return 0;\n}\n\nint algorithm(int n) {          // input data\n    const int a = 0;            // temporary data (constant)\n    int b = 0;                  // temporary data (variable)\n    Node* node = new Node(0);   // temporary data (object)\n    int c = func();             // stack frame space (call function)\n    return a + b + c;           // output data\n}\n
    /* Classes */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* Functions */\nint function() {\n    // Perform certain operations...\n    return 0;\n}\n\nint algorithm(int n) {          // input data\n    final int a = 0;            // temporary data (constant)\n    int b = 0;                  // temporary data (variable)\n    Node node = new Node(0);    // temporary data (object)\n    int c = function();         // stack frame space (call function)\n    return a + b + c;           // output data\n}\n
    /* Classes */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* Functions */\nint Function() {\n    // Perform certain operations...\n    return 0;\n}\n\nint Algorithm(int n) {  // input data\n    const int a = 0;    // temporary data (constant)\n    int b = 0;          // temporary data (variable)\n    Node node = new(0); // temporary data (object)\n    int c = Function(); // stack frame space (call function)\n    return a + b + c;   // output data\n}\n
    /* Structures */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* Create node structure */\nfunc newNode(val int) *node {\n    return &node{val: val}\n}\n\n/* Functions */\nfunc function() int {\n    // Perform certain operations...\n    return 0\n}\n\nfunc algorithm(n int) int { // input data\n    const a = 0             // temporary data (constant)\n    b := 0                  // temporary storage of data (variable)\n    newNode(0)              // temporary data (object)\n    c := function()         // stack frame space (call function)\n    return a + b + c        // output data\n}\n
    /* Classes */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* Functions */\nfunc function() -> Int {\n    // Perform certain operations...\n    return 0\n}\n\nfunc algorithm(n: Int) -> Int { // input data\n    let a = 0                   // temporary data (constant)\n    var b = 0                   // temporary data (variable)\n    let node = Node(x: 0)       // temporary data (object)\n    let c = function()          // stack frame space (call function)\n    return a + b + c            // output data\n}\n
    /* Classes */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // node value\n        this.next = null;                       // reference to the next node\n    }\n}\n\n/* Functions */\nfunction constFunc() {\n    // Perform certain operations\n    return 0;\n}\n\nfunction algorithm(n) {         // input data\n    const a = 0;                // temporary data (constant)\n    let b = 0;                  // temporary data (variable)\n    const node = new Node(0);   // temporary data (object)\n    const c = constFunc();      // Stack frame space (calling function)\n    return a + b + c;           // output data\n}\n
    /* Classes */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // node value\n        this.next = null;                       // reference to the next node\n    }\n}\n\n/* Functions */\nfunction constFunc(): number {\n    // Perform certain operations\n    return 0;\n}\n\nfunction algorithm(n: number): number { // input data\n    const a = 0;                        // temporary data (constant)\n    let b = 0;                          // temporary data (variable)\n    const node = new Node(0);           // temporary data (object)\n    const c = constFunc();              // Stack frame space (calling function)\n    return a + b + c;                   // output data\n}\n
    /* Classes */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* Functions */\nint function() {\n  // Perform certain operations...\n  return 0;\n}\n\nint algorithm(int n) {  // input data\n  const int a = 0;      // temporary data (constant)\n  int b = 0;            // temporary data (variable)\n  Node node = Node(0);  // temporary data (object)\n  int c = function();   // stack frame space (call function)\n  return a + b + c;     // output data\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Structures */\nstruct Node {\n    val: i32,\n    next: Option<Rc<RefCell<Node>>>,\n}\n\n/* Creating a Node structure */\nimpl Node {\n    fn new(val: i32) -> Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* Functions */\nfn function() -> i32 {     \n    // Perform certain operations...\n    return 0;\n}\n\nfn algorithm(n: i32) -> i32 {   // input data\n    const a: i32 = 0;           // temporary data (constant)\n    let mut b = 0;              // temporary data (variable)\n    let node = Node::new(0);    // temporary data (object)\n    let c = function();         // stack frame space (call function)\n    return a + b + c;           // output data\n}\n
    /* Functions */\nint func() {\n    // Perform certain operations...\n    return 0;\n}\n\nint algorithm(int n) {  // input data\n    const int a = 0;    // temporary data (constant)\n    int b = 0;          // temporary data (variable)\n    int c = func();     // stack frame space (call function)\n    return a + b + c;   // output data\n}\n
    \n
    \n
    "},{"location":"chapter_computational_complexity/space_complexity/#242-calculation-method","title":"2.4.2 \u00a0 Calculation Method","text":"

    The method for calculating space complexity is roughly similar to that of time complexity, with the only change being the shift of the statistical object from \"number of operations\" to \"size of used space\".

    However, unlike time complexity, we usually only focus on the worst-case space complexity. This is because memory space is a hard requirement, and we must ensure that there is enough memory space reserved under all input data.

    Consider the following code, the term \"worst-case\" in worst-case space complexity has two meanings.

    1. Based on the worst input data: When \\(n < 10\\), the space complexity is \\(O(1)\\); but when \\(n > 10\\), the initialized array nums occupies \\(O(n)\\) space, thus the worst-case space complexity is \\(O(n)\\).
    2. Based on the peak memory used during the algorithm's execution: For example, before executing the last line, the program occupies \\(O(1)\\) space; when initializing the array nums, the program occupies \\(O(n)\\) space, hence the worst-case space complexity is \\(O(n)\\).
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n > 10:\n        nums = [0] * n  # O(n)\n
    void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector<int> b(10000);    // O(1)\n    if (n > 10)\n        vector<int> nums(n); // O(n)\n}\n
    void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n > 10)\n        int[] nums = new int[n]; // O(n)\n}\n
    void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n > 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n
    func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n > 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n
    func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n > 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n
    function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n > 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n
    function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n > 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n
    void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List<int> b = List.filled(10000, 0);  // O(1)\n  if (n > 10) {\n    List<int> nums = List.filled(n, 0); // O(n)\n  }\n}\n
    fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n > 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n
    void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n > 10)\n        int nums[n] = {0};   // O(n)\n}\n
    \n
    \n

    In recursive functions, stack frame space must be taken into count. Consider the following code:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    def function() -> int:\n    # Perform certain operations\n    return 0\n\ndef loop(n: int):\n    \"\"\"Loop O(1)\"\"\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"Recursion O(n)\"\"\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n
    int func() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n/* Recursion O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    int function() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        function();\n    }\n}\n/* Recursion O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    int Function() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i < n; i++) {\n        Function();\n    }\n}\n/* Recursion O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n
    func function() int {\n    // Perform certain operations\n    return 0\n}\n\n/* Cycle O(1) */\nfunc loop(n int) {\n    for i := 0; i < n; i++ {\n        function()\n    }\n}\n\n/* Recursion O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n
    @discardableResult\nfunc function() -> Int {\n    // Perform certain operations\n    return 0\n}\n\n/* Cycle O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..< n {\n        function()\n    }\n}\n\n/* Recursion O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n
    function constFunc() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nfunction loop(n) {\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n/* Recursion O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n
    function constFunc(): number {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n/* Recursion O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n
    int function() {\n  // Perform certain operations\n  return 0;\n}\n/* Cycle O(1) */\nvoid loop(int n) {\n  for (int i = 0; i < n; i++) {\n    function();\n  }\n}\n/* Recursion O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  return recur(n - 1);\n}\n
    fn function() -> i32 {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* Recursion O(n) */\nvoid recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n
    int func() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n/* Recursion O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    \n
    \n

    The time complexity of both loop() and recur() functions is \\(O(n)\\), but their space complexities differ.

    • The loop() function calls function() \\(n\\) times in a loop, where each iteration's function() returns and releases its stack frame space, so the space complexity remains \\(O(1)\\).
    • The recursive function recur() will have \\(n\\) instances of unreturned recur() existing simultaneously during its execution, thus occupying \\(O(n)\\) stack frame space.
    "},{"location":"chapter_computational_complexity/space_complexity/#243-common-types","title":"2.4.3 \u00a0 Common Types","text":"

    Let the size of the input data be \\(n\\), the following chart displays common types of space complexities (arranged from low to high).

    \\[ \\begin{aligned} O(1) < O(\\log n) < O(n) < O(n^2) < O(2^n) \\newline \\text{Constant Order} < \\text{Logarithmic Order} < \\text{Linear Order} < \\text{Quadratic Order} < \\text{Exponential Order} \\end{aligned} \\]

    Figure 2-16 \u00a0 Common Types of Space Complexity

    "},{"location":"chapter_computational_complexity/space_complexity/#1-constant-order-o1","title":"1. \u00a0 Constant Order \\(O(1)\\)","text":"

    Constant order is common in constants, variables, objects that are independent of the size of input data \\(n\\).

    Note that memory occupied by initializing variables or calling functions in a loop, which is released upon entering the next cycle, does not accumulate over space, thus the space complexity remains \\(O(1)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def function() -> int:\n    \"\"\"\u51fd\u6570\"\"\"\n    # \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n\ndef constant(n: int):\n    \"\"\"\u5e38\u6570\u9636\"\"\"\n    # \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in range(n):\n        c = 0\n    # \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in range(n):\n        function()\n
    space_complexity.cpp
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const int a = 0;\n    int b = 0;\n    vector<int> nums(10000);\n    ListNode node(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n
    space_complexity.java
    /* \u51fd\u6570 */\nint function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        function();\n    }\n}\n
    space_complexity.cs
    /* \u51fd\u6570 */\nint Function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid Constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        Function();\n    }\n}\n
    space_complexity.go
    /* \u51fd\u6570 */\nfunc function() int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfunc spaceConstant(n int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    var c int\n    for i := 0; i < n; i++ {\n        c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for i := 0; i < n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n
    space_complexity.swift
    /* \u51fd\u6570 */\n@discardableResult\nfunc function() -> Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfunc constant(n: Int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in 0 ..< n {\n        let c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in 0 ..< n {\n        function()\n    }\n}\n
    space_complexity.js
    /* \u51fd\u6570 */\nfunction constFunc() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nfunction constant(n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        const c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n
    space_complexity.ts
    /* \u51fd\u6570 */\nfunction constFunc(): number {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nfunction constant(n: number): void {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        const c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n
    space_complexity.dart
    /* \u51fd\u6570 */\nint function() {\n  // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n  return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n  // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n  final int a = 0;\n  int b = 0;\n  List<int> nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n  for (var i = 0; i < n; i++) {\n    int c = 0;\n  }\n  // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n  for (var i = 0; i < n; i++) {\n    function();\n  }\n}\n
    space_complexity.rs
    /* \u51fd\u6570 */\nfn function() -> i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\n#[allow(unused)]\nfn constant(n: i32) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for i in 0..n {\n        let c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for i in 0..n {\n        function();\n    }\n}\n
    space_complexity.c
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n
    space_complexity.kt
    /* \u51fd\u6570 */\nfun function(): Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfun constant(n: Int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (i in 0..<n) {\n        val c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (i in 0..<n) {\n        function()\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{function}\n\n[class]{}-[func]{constant}\n
    space_complexity.zig
    // \u51fd\u6570\nfn function() i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n// \u5e38\u6570\u9636\nfn constant(n: i32) void {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a: i32 = 0;\n    var b: i32 = 0;\n    var nums = [_]i32{0}**10000;\n    var node = inc.ListNode(i32){.val = 0};\n    var i: i32 = 0;\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    while (i < n) : (i += 1) {\n        var c: i32 = 0;\n        _ = c;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    i = 0;\n    while (i < n) : (i += 1) {\n        _ = function();\n    }\n    _ = a;\n    _ = b;\n    _ = nums;\n    _ = node;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_computational_complexity/space_complexity/#2-linear-order-on","title":"2. \u00a0 Linear Order \\(O(n)\\)","text":"

    Linear order is common in arrays, linked lists, stacks, queues, etc., where the number of elements is proportional to \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def linear(n: int):\n    \"\"\"\u7ebf\u6027\u9636\"\"\"\n    # \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    nums = [0] * n\n    # \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\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\n    vector<int> nums(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    vector<ListNode> nodes;\n    for (int i = 0; i < n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    unordered_map<int, string> map;\n    for (int i = 0; i < n; i++) {\n        map[i] = to_string(i);\n    }\n}\n
    space_complexity.java
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    int[] nums = new int[n];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    List<ListNode> nodes = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    Map<Integer, String> map = new HashMap<>();\n    for (int i = 0; i < n; i++) {\n        map.put(i, String.valueOf(i));\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\n    int[] nums = new int[n];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    List<ListNode> nodes = [];\n    for (int i = 0; i < n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    Dictionary<int, string> map = [];\n    for (int i = 0; i < n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\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\n    var nodes []*node\n    for i := 0; i < n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    m := make(map[int]string, n)\n    for i := 0; i < n; i++ {\n        m[i] = strconv.Itoa(i)\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\n    let nums = Array(repeating: 0, count: n)\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let nodes = (0 ..< n).map { ListNode(x: $0) }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, \"\\($0)\") })\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\n    const nums = new Array(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const nodes = [];\n    for (let i = 0; i < n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const map = new Map();\n    for (let i = 0; i < n; i++) {\n        map.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\n    const nums = new Array(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const nodes: ListNode[] = [];\n    for (let i = 0; i < n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const map = new Map();\n    for (let i = 0; i < n; i++) {\n        map.set(i, i.toString());\n    }\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\n  List<int> nums = List.filled(n, 0);\n  // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n  List<ListNode> nodes = [];\n  for (var i = 0; i < n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n  Map<int, String> map = HashMap();\n  for (var i = 0; i < n; i++) {\n    map.putIfAbsent(i, () => i.toString());\n  }\n}\n
    space_complexity.rs
    /* \u7ebf\u6027\u9636 */\n#[allow(unused)]\nfn linear(n: i32) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut nums = vec![0; n as usize];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n
    space_complexity.c
    /* \u54c8\u5e0c\u8868 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n} HashTable;\n\n/* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i < n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // \u5185\u5b58\u91ca\u653e\n    for (int i = 0; i < n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    HashTable *h = NULL;\n    for (int i = 0; i < n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp->key = i;\n        tmp->val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // \u5185\u5b58\u91ca\u653e\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n
    space_complexity.kt
    /* \u7ebf\u6027\u9636 */\nfun linear(n: Int) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    val nums = Array(n) { 0 }\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    val nodes = mutableListOf<ListNode>()\n    for (i in 0..<n) {\n        nodes.add(ListNode(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    val map = mutableMapOf<Int, String>()\n    for (i in 0..<n) {\n        map[i] = i.toString()\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{linear}\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\n    var nums = [_]i32{0}**n;\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    var nodes = std.ArrayList(i32).init(std.heap.page_allocator);\n    defer nodes.deinit();\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        try nodes.append(i);\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    var map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator);\n    defer map.deinit();\n    var j: i32 = 0;\n    while (j < n) : (j += 1) {\n        const string = try std.fmt.allocPrint(std.heap.page_allocator, \"{d}\", .{j});\n        defer std.heap.page_allocator.free(string);\n        try map.put(i, string);\n    }\n    _ = nums;\n}\n
    Code Visualization

    Full Screen >

    As shown below, this function's recursive depth is \\(n\\), meaning there are \\(n\\) instances of unreturned linear_recur() function, using \\(O(n)\\) size of stack frame space:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def linear_recur(n: int):\n    \"\"\"\u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    print(\"\u9012\u5f52 n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n
    space_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    cout << \"\u9012\u5f52 n = \" << n << endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    System.out.println(\"\u9012\u5f52 n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"\u9012\u5f52 n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n
    space_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"\u9012\u5f52 n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n
    space_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc linearRecur(n: Int) {\n    print(\"\u9012\u5f52 n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n
    space_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n) {\n    console.log(`\u9012\u5f52 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n: number): void {\n    console.log(`\u9012\u5f52 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n  print('\u9012\u5f52 n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n
    space_complexity.rs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn linear_recur(n: i32) {\n    println!(\"\u9012\u5f52 n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n
    space_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    printf(\"\u9012\u5f52 n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.kt
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun linearRecur(n: Int) {\n    println(\"\u9012\u5f52 n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n
    space_complexity.rb
    [class]{}-[func]{linear_recur}\n
    space_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn linearRecur(comptime n: i32) void {\n    std.debug.print(\"\u9012\u5f52 n = {}\\n\", .{n});\n    if (n == 1) return;\n    linearRecur(n - 1);\n}\n
    Code Visualization

    Full Screen >

    Figure 2-17 \u00a0 Recursive Function Generating Linear Order Space Complexity

    "},{"location":"chapter_computational_complexity/space_complexity/#3-quadratic-order-on2","title":"3. \u00a0 Quadratic Order \\(O(n^2)\\)","text":"

    Quadratic order is common in matrices and graphs, where the number of elements is quadratic to \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def quadratic(n: int):\n    \"\"\"\u5e73\u65b9\u9636\"\"\"\n    # \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    num_matrix = [[0] * n for _ in range(n)]\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    vector<vector<int>> numMatrix;\n    for (int i = 0; i < n; i++) {\n        vector<int> tmp;\n        for (int j = 0; j < n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n
    space_complexity.java
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    int[][] numMatrix = new int[n][n];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    List<List<Integer>> numList = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        List<Integer> tmp = new ArrayList<>();\n        for (int j = 0; j < n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636 */\nvoid Quadratic(int n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    int[,] numMatrix = new int[n, n];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    List<List<int>> numList = [];\n    for (int i = 0; i < n; i++) {\n        List<int> tmp = [];\n        for (int j = 0; j < n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n
    space_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc spaceQuadratic(n int) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    numMatrix := make([][]int, n)\n    for i := 0; i < n; i++ {\n        numMatrix[i] = make([]int, n)\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\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() => Array(n).fill(null));\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numList = [];\n    for (let i = 0; i < n; i++) {\n        const tmp = [];\n        for (let j = 0; j < n; j++) {\n            tmp.push(0);\n        }\n        numList.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\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() => Array(n).fill(null));\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numList = [];\n    for (let i = 0; i < n; i++) {\n        const tmp = [];\n        for (let j = 0; j < n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n  // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n  List<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));\n  // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n  List<List<int>> numList = [];\n  for (var i = 0; i < n; i++) {\n    List<int> tmp = [];\n    for (int j = 0; j < n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n
    space_complexity.rs
    /* \u5e73\u65b9\u9636 */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.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\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i < n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j < n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // \u5185\u5b58\u91ca\u653e\n    for (int i = 0; i < n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n
    space_complexity.kt
    /* \u5e73\u65b9\u9636 */\nfun quadratic(n: Int) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    val numMatrix: Array<Array<Int>?> = arrayOfNulls(n)\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    val numList: MutableList<MutableList<Int>> = arrayListOf()\n    for (i in 0..<n) {\n        val tmp = mutableListOf<Int>()\n        for (j in 0..<n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{quadratic}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) !void {\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    var nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator);\n    defer nodes.deinit();\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        var tmp = std.ArrayList(i32).init(std.heap.page_allocator);\n        defer tmp.deinit();\n        var j: i32 = 0;\n        while (j < n) : (j += 1) {\n            try tmp.append(0);\n        }\n        try nodes.append(tmp);\n    }\n}\n
    Code Visualization

    Full Screen >

    As shown below, the recursive depth of this function is \\(n\\), and in each recursive call, an array is initialized with lengths \\(n\\), \\(n-1\\), \\(\\dots\\), \\(2\\), \\(1\\), averaging \\(n/2\\), thus overall occupying \\(O(n^2)\\) space:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def quadratic_recur(n: int) -> int:\n    \"\"\"\u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n <= 0:\n        return 0\n    # \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    vector<int> nums(n);\n    cout << \"\u9012\u5f52 n = \" << n << \" \u4e2d\u7684 nums \u957f\u5ea6 = \" << nums.size() << endl;\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint QuadraticRecur(int n) {\n    if (n <= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n
    space_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceQuadraticRecur(n int) int {\n    if n <= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n
    space_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\n@discardableResult\nfunc quadraticRecur(n: Int) -> Int {\n    if n <= 0 {\n        return 0\n    }\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"\u9012\u5f52 n = \\(n) \u4e2d\u7684 nums \u957f\u5ea6 = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n) {\n    if (n <= 0) return 0;\n    const nums = new Array(n);\n    console.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n: number): number {\n    if (n <= 0) return 0;\n    const nums = new Array(n);\n    console.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n  if (n <= 0) return 0;\n  List<int> nums = List.filled(n, 0);\n  print('\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n
    space_complexity.rs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn quadratic_recur(n: i32) -> i32 {\n    if n <= 0 {\n        return 0;\n    };\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n
    space_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n
    space_complexity.kt
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n <= 0)\n        return 0\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n
    space_complexity.rb
    [class]{}-[func]{quadratic_recur}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn quadraticRecur(comptime n: i32) i32 {\n    if (n <= 0) return 0;\n    var nums = [_]i32{0}**n;\n    std.debug.print(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\\n\", .{n, nums.len});\n    return quadraticRecur(n - 1);\n}\n
    Code Visualization

    Full Screen >

    Figure 2-18 \u00a0 Recursive Function Generating Quadratic Order Space Complexity

    "},{"location":"chapter_computational_complexity/space_complexity/#4-exponential-order-o2n","title":"4. \u00a0 Exponential Order \\(O(2^n)\\)","text":"

    Exponential order is common in binary trees. Observe the below image, a \"full binary tree\" with \\(n\\) levels has \\(2^n - 1\\) nodes, occupying \\(O(2^n)\\) space:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def build_tree(n: int) -> TreeNode | None:\n    \"\"\"\u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n
    space_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root->left = buildTree(n - 1);\n    root->right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.java
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n
    space_complexity.go
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n
    space_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n: Int) -> TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n
    space_complexity.js
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n
    space_complexity.rs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfn build_tree(n: i32) -> Option<Rc<RefCell<TreeNode>>> {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n
    space_complexity.c
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root->left = buildTree(n - 1);\n    root->right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.kt
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n
    space_complexity.rb
    [class]{}-[func]{build_tree}\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) {\n    if (n == 0) return null;\n    const root = try mem_allocator.create(inc.TreeNode(i32));\n    root.init(0);\n    root.left = try buildTree(mem_allocator, n - 1);\n    root.right = try buildTree(mem_allocator, n - 1);\n    return root;\n}\n
    Code Visualization

    Full Screen >

    Figure 2-19 \u00a0 Full Binary Tree Generating Exponential Order Space Complexity

    "},{"location":"chapter_computational_complexity/space_complexity/#5-logarithmic-order-olog-n","title":"5. \u00a0 Logarithmic Order \\(O(\\log n)\\)","text":"

    Logarithmic order is common in divide-and-conquer algorithms. For example, in merge sort, an array of length \\(n\\) is recursively divided in half each round, forming a recursion tree of height \\(\\log n\\), using \\(O(\\log n)\\) stack frame space.

    Another example is converting a number to a string. Given a positive integer \\(n\\), its number of digits is \\(\\log_{10} n + 1\\), corresponding to the length of the string, thus the space complexity is \\(O(\\log_{10} n + 1) = O(\\log n)\\).

    "},{"location":"chapter_computational_complexity/space_complexity/#244-balancing-time-and-space","title":"2.4.4 \u00a0 Balancing Time and Space","text":"

    Ideally, we aim for both time complexity and space complexity to be optimal. However, in practice, optimizing both simultaneously is often difficult.

    Lowering time complexity usually comes at the cost of increased space complexity, and vice versa. The approach of sacrificing memory space to improve algorithm speed is known as \"space-time tradeoff\"; the reverse is known as \"time-space tradeoff\".

    The choice depends on which aspect we value more. In most cases, time is more precious than space, so \"space-time tradeoff\" is often the more common strategy. Of course, controlling space complexity is also very important when dealing with large volumes of data.

    "},{"location":"chapter_computational_complexity/summary/","title":"2.5 \u00a0 Summary","text":""},{"location":"chapter_computational_complexity/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"

    Algorithm Efficiency Assessment

    • Time efficiency and space efficiency are the two main criteria for assessing the merits of an algorithm.
    • We can assess algorithm efficiency through actual testing, but it's challenging to eliminate the influence of the test environment, and it consumes substantial computational resources.
    • Complexity analysis can overcome the disadvantages of actual testing. Its results are applicable across all operating platforms and can reveal the efficiency of algorithms at different data scales.

    Time Complexity

    • Time complexity measures the trend of an algorithm's running time with the increase in data volume, effectively assessing algorithm efficiency. However, it can fail in certain cases, such as with small input data volumes or when time complexities are the same, making it challenging to precisely compare the efficiency of algorithms.
    • Worst-case time complexity is denoted using big O notation, representing the asymptotic upper bound, reflecting the growth level of the number of operations \\(T(n)\\) as \\(n\\) approaches infinity.
    • Calculating time complexity involves two steps: first counting the number of operations, then determining the asymptotic upper bound.
    • Common time complexities, arranged from low to high, include \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n \\log n)\\), \\(O(n^2)\\), \\(O(2^n)\\), and \\(O(n!)\\), among others.
    • The time complexity of some algorithms is not fixed and depends on the distribution of input data. Time complexities are divided into worst, best, and average cases. The best case is rarely used because input data generally needs to meet strict conditions to achieve the best case.
    • Average time complexity reflects the efficiency of an algorithm under random data inputs, closely resembling the algorithm's performance in actual applications. Calculating average time complexity requires accounting for the distribution of input data and the subsequent mathematical expectation.

    Space Complexity

    • Space complexity, similar to time complexity, measures the trend of memory space occupied by an algorithm with the increase in data volume.
    • The relevant memory space used during the algorithm's execution can be divided into input space, temporary space, and output space. Generally, input space is not included in space complexity calculations. Temporary space can be divided into temporary data, stack frame space, and instruction space, where stack frame space usually affects space complexity only in recursive functions.
    • We usually focus only on the worst-case space complexity, which means calculating the space complexity of the algorithm under the worst input data and at the worst moment of operation.
    • Common space complexities, arranged from low to high, include \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n^2)\\), and \\(O(2^n)\\), among others.
    "},{"location":"chapter_computational_complexity/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Is the space complexity of tail recursion \\(O(1)\\)?

    Theoretically, the space complexity of a tail-recursive function can be optimized to \\(O(1)\\). However, most programming languages (such as Java, Python, C++, Go, C#) do not support automatic optimization of tail recursion, so it's generally considered to have a space complexity of \\(O(n)\\).

    Q: What is the difference between the terms \"function\" and \"method\"?

    A \"function\" can be executed independently, with all parameters passed explicitly. A \"method\" is associated with an object and is implicitly passed to the object calling it, able to operate on the data contained within an instance of a class.

    Here are some examples from common programming languages:

    • C is a procedural programming language without object-oriented concepts, so it only has functions. However, we can simulate object-oriented programming by creating structures (struct), and functions associated with these structures are equivalent to methods in other programming languages.
    • Java and C# are object-oriented programming languages where code blocks (methods) are typically part of a class. Static methods behave like functions because they are bound to the class and cannot access specific instance variables.
    • C++ and Python support both procedural programming (functions) and object-oriented programming (methods).

    Q: Does the \"Common Types of Space Complexity\" figure reflect the absolute size of occupied space?

    No, the figure shows space complexities, which reflect growth trends, not the absolute size of the occupied space.

    If you take \\(n = 8\\), you might find that the values of each curve don't correspond to their functions. This is because each curve includes a constant term, intended to compress the value range into a visually comfortable range.

    In practice, since we usually don't know the \"constant term\" complexity of each method, it's generally not possible to choose the best solution for \\(n = 8\\) based solely on complexity. However, for \\(n = 8^5\\), it's much easier to choose, as the growth trend becomes dominant.

    "},{"location":"chapter_computational_complexity/time_complexity/","title":"2.3 \u00a0 Time Complexity","text":"

    Time complexity is a concept used to measure how the run time of an algorithm increases with the size of the input data. Understanding time complexity is crucial for accurately assessing the efficiency of an algorithm.

    1. Determining the Running Platform: This includes hardware configuration, programming language, system environment, etc., all of which can affect the efficiency of code execution.
    2. Evaluating the Run Time for Various Computational Operations: For instance, an addition operation + might take 1 ns, a multiplication operation * might take 10 ns, a print operation print() might take 5 ns, etc.
    3. Counting All the Computational Operations in the Code: Summing the execution times of all these operations gives the total run time.

    For example, consider the following code with an input size of \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    # Under an operating platform\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # Cycle n times\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n
    // Under a particular operating platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i < n; i++) {  // 1 ns , every round i++ is executed\n        cout << 0 << endl;         // 5 ns\n    }\n}\n
    // Under a particular operating platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i < n; i++) {  // 1 ns , every round i++ is executed\n        System.out.println(0);     // 5 ns\n    }\n}\n
    // Under a particular operating platform\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i < n; i++) {  // 1 ns , every round i++ is executed\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n
    // Under a particular operating platform\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // Loop n times\n    for i := 0; i < n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n
    // Under a particular operating platform\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // Loop n times\n    for _ in 0 ..< n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n
    // Under a particular operating platform\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // Loop n times\n    for(let i = 0; i < n; i++) { // 1 ns , every round i++ is executed\n        console.log(0); // 5 ns\n    }\n}\n
    // Under a particular operating platform\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // Loop n times\n    for(let i = 0; i < n; i++) { // 1 ns , every round i++ is executed\n        console.log(0); // 5 ns\n    }\n}\n
    // Under a particular operating platform\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // Loop n times\n  for (int i = 0; i < n; i++) { // 1 ns , every round i++ is executed\n    print(0); // 5 ns\n  }\n}\n
    // Under a particular operating platform\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // Loop n times\n    for _ in 0..n {     // 1 ns for each round i++\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n
    // Under a particular operating platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i < n; i++) {   // 1 ns , every round i++ is executed\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n
    \n
    // Under a particular operating platform\nfn algorithm(n: usize) void {\n    var a: i32 = 2; // 1 ns\n    a += 1; // 1 ns\n    a *= 2; // 10 ns\n    // Loop n times\n    for (0..n) |_| { // 1 ns\n        std.debug.print(\"{}\\n\", .{0}); // 5 ns\n    }\n}\n

    Using the above method, the run time of the algorithm can be calculated as \\((6n + 12)\\) ns:

    \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\]

    However, in practice, counting the run time of an algorithm is neither practical nor reasonable. First, we don't want to tie the estimated time to the running platform, as algorithms need to run on various platforms. Second, it's challenging to know the run time for each type of operation, making the estimation process difficult.

    "},{"location":"chapter_computational_complexity/time_complexity/#231-assessing-time-growth-trend","title":"2.3.1 \u00a0 Assessing Time Growth Trend","text":"

    Time complexity analysis does not count the algorithm's run time, but rather the growth trend of the run time as the data volume increases.

    Let's understand this concept of \"time growth trend\" with an example. Assume the input data size is \\(n\\), and consider three algorithms A, B, and C:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    # Time complexity of algorithm A: constant order\ndef algorithm_A(n: int):\n    print(0)\n# Time complexity of algorithm B: linear order\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# Time complexity of algorithm C: constant order\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n
    // Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    cout << 0 << endl;\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        cout << 0 << endl;\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        cout << 0 << endl;\n    }\n}\n
    // Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        System.out.println(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        System.out.println(0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// Time complexity of algorithm B: linear order\nvoid AlgorithmB(int n) {\n    for (int i = 0; i < n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid AlgorithmC(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// Time complexity of algorithm B: linear order\nfunc algorithm_B(n int) {\n    for i := 0; i < n; i++ {\n        fmt.Println(0)\n    }\n}\n// Time complexity of algorithm C: constant order\nfunc algorithm_C(n int) {\n    for i := 0; i < 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n
    // Time complexity of algorithm A: constant order\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// Time complexity of algorithm B: linear order\nfunc algorithmB(n: Int) {\n    for _ in 0 ..< n {\n        print(0)\n    }\n}\n\n// Time complexity of algorithm C: constant order\nfunc algorithmC(n: Int) {\n    for _ in 0 ..< 1_000_000 {\n        print(0)\n    }\n}\n
    // Time complexity of algorithm A: constant order\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// Time complexity of algorithm B: linear order\nfunction algorithm_B(n) {\n    for (let i = 0; i < n; i++) {\n        console.log(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfunction algorithm_C(n) {\n    for (let i = 0; i < 1000000; i++) {\n        console.log(0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// Time complexity of algorithm B: linear order\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i < n; i++) {\n        console.log(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i < 1000000; i++) {\n        console.log(0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nvoid algorithmA(int n) {\n  print(0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithmB(int n) {\n  for (int i = 0; i < n; i++) {\n    print(0);\n  }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithmC(int n) {\n  for (int i = 0; i < 1000000; i++) {\n    print(0);\n  }\n}\n
    // Time complexity of algorithm A: constant order\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// Time complexity of algorithm B: linear order\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n
    \n
    // Time complexity of algorithm A: constant order\nfn algorithm_A(n: usize) void {\n    _ = n;\n    std.debug.print(\"{}\\n\", .{0});\n}\n// Time complexity of algorithm B: linear order\nfn algorithm_B(n: i32) void {\n    for (0..n) |_| {\n        std.debug.print(\"{}\\n\", .{0});\n    }\n}\n// Time complexity of algorithm C: constant order\nfn algorithm_C(n: i32) void {\n    _ = n;\n    for (0..1000000) |_| {\n        std.debug.print(\"{}\\n\", .{0});\n    }\n}\n

    The following figure shows the time complexities of these three algorithms.

    • Algorithm A has just one print operation, and its run time does not grow with \\(n\\). Its time complexity is considered \"constant order.\"
    • Algorithm B involves a print operation looping \\(n\\) times, and its run time grows linearly with \\(n\\). Its time complexity is \"linear order.\"
    • Algorithm C has a print operation looping 1,000,000 times. Although it takes a long time, it is independent of the input data size \\(n\\). Therefore, the time complexity of C is the same as A, which is \"constant order.\"

    Figure 2-7 \u00a0 Time Growth Trend of Algorithms A, B, and C

    Compared to directly counting the run time of an algorithm, what are the characteristics of time complexity analysis?

    • Time complexity effectively assesses algorithm efficiency. For instance, algorithm B has linearly growing run time, which is slower than algorithm A when \\(n > 1\\) and slower than C when \\(n > 1,000,000\\). In fact, as long as the input data size \\(n\\) is sufficiently large, a \"constant order\" complexity algorithm will always be better than a \"linear order\" one, demonstrating the essence of time growth trend.
    • Time complexity analysis is more straightforward. Obviously, the running platform and the types of computational operations are irrelevant to the trend of run time growth. Therefore, in time complexity analysis, we can simply treat the execution time of all computational operations as the same \"unit time,\" simplifying the \"computational operation run time count\" to a \"computational operation count.\" This significantly reduces the complexity of estimation.
    • Time complexity has its limitations. For example, although algorithms A and C have the same time complexity, their actual run times can be quite different. Similarly, even though algorithm B has a higher time complexity than C, it is clearly superior when the input data size \\(n\\) is small. In these cases, it's difficult to judge the efficiency of algorithms based solely on time complexity. Nonetheless, despite these issues, complexity analysis remains the most effective and commonly used method for evaluating algorithm efficiency.
    "},{"location":"chapter_computational_complexity/time_complexity/#232-asymptotic-upper-bound","title":"2.3.2 \u00a0 Asymptotic Upper Bound","text":"

    Consider a function with an input size of \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # Cycle n times\n    for i in range(n):  # +1\n        print(0)        # +1\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i < n; i++) { // +1 (execute i ++ every round)\n        cout << 0 << endl;    // +1\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i < n; i++) { // +1 (execute i ++ every round)\n        System.out.println(0);    // +1\n    }\n}\n
    void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i < n; i++) {   // +1 (execute i ++ every round)\n        Console.WriteLine(0);   // +1\n    }\n}\n
    func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // Loop n times\n    for i := 0; i < n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n
    func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Loop n times\n    for _ in 0 ..< n { // +1\n        print(0) // +1\n    }\n}\n
    function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for(let i = 0; i < n; i++){ // +1 (execute i ++ every round)\n        console.log(0); // +1\n    }\n}\n
    function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for(let i = 0; i < n; i++){ // +1 (execute i ++ every round)\n        console.log(0); // +1\n    }\n}\n
    void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // Loop n times\n  for (int i = 0; i < n; i++) { // +1 (execute i ++ every round)\n    print(0); // +1\n  }\n}\n
    fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // Loop n times\n    for _ in 0..n { // +1 (execute i ++ every round)\n        println!(\"{}\", 0); // +1\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i < n; i++) {   // +1 (execute i ++ every round)\n        printf(\"%d\", 0);            // +1\n    }\n} \n
    \n
    fn algorithm(n: usize) void {\n    var a: i32 = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for (0..n) |_| { // +1 (execute i ++ every round)\n        std.debug.print(\"{}\\n\", .{0}); // +1\n    }\n}\n

    Given a function that represents the number of operations of an algorithm as a function of the input size \\(n\\), denoted as \\(T(n)\\), consider the following example:

    \\[ T(n) = 3 + 2n \\]

    Since \\(T(n)\\) is a linear function, its growth trend is linear, and therefore, its time complexity is of linear order, denoted as \\(O(n)\\). This mathematical notation, known as \"big-O notation,\" represents the \"asymptotic upper bound\" of the function \\(T(n)\\).

    In essence, time complexity analysis is about finding the asymptotic upper bound of the \"number of operations \\(T(n)\\)\". It has a precise mathematical definition.

    Asymptotic Upper Bound

    If there exist positive real numbers \\(c\\) and \\(n_0\\) such that for all \\(n > n_0\\), \\(T(n) \\leq c \\cdot f(n)\\), then \\(f(n)\\) is considered an asymptotic upper bound of \\(T(n)\\), denoted as \\(T(n) = O(f(n))\\).

    As illustrated below, calculating the asymptotic upper bound involves finding a function \\(f(n)\\) such that, as \\(n\\) approaches infinity, \\(T(n)\\) and \\(f(n)\\) have the same growth order, differing only by a constant factor \\(c\\).

    Figure 2-8 \u00a0 Asymptotic Upper Bound of a Function

    "},{"location":"chapter_computational_complexity/time_complexity/#233-calculation-method","title":"2.3.3 \u00a0 Calculation Method","text":"

    While the concept of asymptotic upper bound might seem mathematically dense, you don't need to fully grasp it right away. Let's first understand the method of calculation, which can be practiced and comprehended over time.

    Once \\(f(n)\\) is determined, we obtain the time complexity \\(O(f(n))\\). But how do we determine the asymptotic upper bound \\(f(n)\\)? This process generally involves two steps: counting the number of operations and determining the asymptotic upper bound.

    "},{"location":"chapter_computational_complexity/time_complexity/#1-step-1-counting-the-number-of-operations","title":"1. \u00a0 Step 1: Counting the Number of Operations","text":"

    This step involves going through the code line by line. However, due to the presence of the constant \\(c\\) in \\(c \\cdot f(n)\\), all coefficients and constant terms in \\(T(n)\\) can be ignored. This principle allows for simplification techniques in counting operations.

    1. Ignore constant terms in \\(T(n)\\), as they do not affect the time complexity being independent of \\(n\\).
    2. Omit all coefficients. For example, looping \\(2n\\), \\(5n + 1\\) times, etc., can be simplified to \\(n\\) times since the coefficient before \\(n\\) does not impact the time complexity.
    3. Use multiplication for nested loops. The total number of operations equals the product of the number of operations in each loop, applying the simplification techniques from points 1 and 2 for each loop level.

    Given a function, we can use these techniques to count operations:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    def algorithm(n: int):\n    a = 1      # +0 (trick 1)\n    a = a + n  # +0 (trick 1)\n    # +n (technique 2)\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n (technique 3)\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n
    void algorithm(int n) {\n    int a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (int i = 0; i < 5 * n + 1; i++) {\n        cout << 0 << endl;\n    }\n    // +n*n (technique 3)\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            cout << 0 << endl;\n        }\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (int i = 0; i < 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n (technique 3)\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n
    void Algorithm(int n) {\n    int a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (int i = 0; i < 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n (technique 3)\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n
    func algorithm(n int) {\n    a := 1     // +0 (trick 1)\n    a = a + n  // +0 (trick 1)\n    // +n (technique 2)\n    for i := 0; i < 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n (technique 3)\n    for i := 0; i < 2 * n; i++ {\n        for j := 0; j < n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n
    func algorithm(n: Int) {\n    var a = 1 // +0 (trick 1)\n    a = a + n // +0 (trick 1)\n    // +n (technique 2)\n    for _ in 0 ..< (5 * n + 1) {\n        print(0)\n    }\n    // +n*n (technique 3)\n    for _ in 0 ..< (2 * n) {\n        for _ in 0 ..< (n + 1) {\n            print(0)\n        }\n    }\n}\n
    function algorithm(n) {\n    let a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (let i = 0; i < 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (technique 3)\n    for (let i = 0; i < 2 * n; i++) {\n        for (let j = 0; j < n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n
    function algorithm(n: number): void {\n    let a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (let i = 0; i < 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (technique 3)\n    for (let i = 0; i < 2 * n; i++) {\n        for (let j = 0; j < n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n
    void algorithm(int n) {\n  int a = 1; // +0 (trick 1)\n  a = a + n; // +0 (trick 1)\n  // +n (technique 2)\n  for (int i = 0; i < 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n (technique 3)\n  for (int i = 0; i < 2 * n; i++) {\n    for (int j = 0; j < n + 1; j++) {\n      print(0);\n    }\n  }\n}\n
    fn algorithm(n: i32) {\n    let mut a = 1;     // +0 (trick 1)\n    a = a + n;        // +0 (trick 1)\n\n    // +n (technique 2)\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n (technique 3)\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (int i = 0; i < 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n (technique 3)\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n
    \n
    fn algorithm(n: usize) void {\n    var a: i32 = 1;     // +0 (trick 1)\n    a = a + @as(i32, @intCast(n));        // +0 (trick 1)\n\n    // +n (technique 2)\n    for(0..(5 * n + 1)) |_| {\n        std.debug.print(\"{}\\n\", .{0});\n    }\n\n    // +n*n (technique 3)\n    for(0..(2 * n)) |_| {\n        for(0..(n + 1)) |_| {\n            std.debug.print(\"{}\\n\", .{0});\n        }\n    }\n}\n

    The formula below shows the counting results before and after simplification, both leading to a time complexity of \\(O(n^2)\\):

    \\[ \\begin{aligned} T(n) & = 2n(n + 1) + (5n + 1) + 2 & \\text{Complete Count (-.-|||)} \\newline & = 2n^2 + 7n + 3 \\newline T(n) & = n^2 + n & \\text{Simplified Count (o.O)} \\end{aligned} \\]"},{"location":"chapter_computational_complexity/time_complexity/#2-step-2-determining-the-asymptotic-upper-bound","title":"2. \u00a0 Step 2: Determining the Asymptotic Upper Bound","text":"

    The time complexity is determined by the highest order term in \\(T(n)\\). This is because, as \\(n\\) approaches infinity, the highest order term dominates, rendering the influence of other terms negligible.

    The following table illustrates examples of different operation counts and their corresponding time complexities. Some exaggerated values are used to emphasize that coefficients cannot alter the order of growth. When \\(n\\) becomes very large, these constants become insignificant.

    Table: Time Complexity for Different Operation Counts

    Operation Count \\(T(n)\\) Time Complexity \\(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/#234-common-types-of-time-complexity","title":"2.3.4 \u00a0 Common Types of Time Complexity","text":"

    Let's consider the input data size as \\(n\\). The common types of time complexities are illustrated below, arranged from lowest to highest:

    \\[ \\begin{aligned} O(1) < O(\\log n) < O(n) < O(n \\log n) < O(n^2) < O(2^n) < O(n!) \\newline \\text{Constant Order} < \\text{Logarithmic Order} < \\text{Linear Order} < \\text{Linear-Logarithmic Order} < \\text{Quadratic Order} < \\text{Exponential Order} < \\text{Factorial Order} \\end{aligned} \\]

    Figure 2-9 \u00a0 Common Types of Time Complexity

    "},{"location":"chapter_computational_complexity/time_complexity/#1-constant-order-o1","title":"1. \u00a0 Constant Order \\(O(1)\\)","text":"

    Constant order means the number of operations is independent of the input data size \\(n\\). In the following function, although the number of operations size might be large, the time complexity remains \\(O(1)\\) as it's unrelated to \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def constant(n: int) -> int:\n    \"\"\"\u5e38\u6570\u9636\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.java
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.cs
    /* \u5e38\u6570\u9636 */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.go
    /* \u5e38\u6570\u9636 */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i < size; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e38\u6570\u9636 */\nfunc constant(n: Int) -> Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..< size {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e38\u6570\u9636 */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i < size; i++) count++;\n    return count;\n}\n
    time_complexity.ts
    /* \u5e38\u6570\u9636 */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i < size; i++) count++;\n    return count;\n}\n
    time_complexity.dart
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i < size; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e38\u6570\u9636 */\nfn constant(n: i32) -> i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i < size; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e38\u6570\u9636 */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 10_0000\n    for (i in 0..<size)\n        count++\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{constant}\n
    time_complexity.zig
    // \u5e38\u6570\u9636\nfn constant(n: i32) i32 {\n    _ = n;\n    var count: i32 = 0;\n    const size: i32 = 100_000;\n    var i: i32 = 0;\n    while(i<size) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_computational_complexity/time_complexity/#2-linear-order-on","title":"2. \u00a0 Linear Order \\(O(n)\\)","text":"

    Linear order indicates the number of operations grows linearly with the input data size \\(n\\). Linear order commonly appears in single-loop structures:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def linear(n: int) -> int:\n    \"\"\"\u7ebf\u6027\u9636\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636 */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u9636 */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i < n; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636 */\nfunc linear(n: Int) -> Int {\n    var count = 0\n    for _ in 0 ..< n {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636 */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i < n; i++) count++;\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636 */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i < n; i++) count++;\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i < n; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u9636 */\nfn linear(n: i32) -> i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u9636 */\nfun linear(n: Int): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (i in 0..<n)\n        count++\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{linear}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\nfn linear(n: i32) i32 {\n    var count: i32 = 0;\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    Operations like array traversal and linked list traversal have a time complexity of \\(O(n)\\), where \\(n\\) is the length of the array or list:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def array_traversal(nums: list[int]) -> int:\n    \"\"\"\u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\"\"\"\n    count = 0\n    # \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for num in nums:\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(vector<int> &nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for range nums {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums: [Int]) -> Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (let i = 0; i < nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (let i = 0; i < nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(List<int> nums) {\n  int count = 0;\n  // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfn array_traversal(nums: &[i32]) -> i32 {\n    let mut count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{array_traversal}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\nfn arrayTraversal(nums: []i32) i32 {\n    var count: i32 = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (nums) |_| {\n        count += 1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    It's important to note that the input data size \\(n\\) should be determined based on the type of input data. For example, in the first example, \\(n\\) represents the input data size, while in the second example, the length of the array \\(n\\) is the data size.

    "},{"location":"chapter_computational_complexity/time_complexity/#3-quadratic-order-on2","title":"3. \u00a0 Quadratic Order \\(O(n^2)\\)","text":"

    Quadratic order means the number of operations grows quadratically with the input data size \\(n\\). Quadratic order typically appears in nested loops, where both the outer and inner loops have a time complexity of \\(O(n)\\), resulting in an overall complexity of \\(O(n^2)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def quadratic(n: int) -> int:\n    \"\"\"\u5e73\u65b9\u9636\"\"\"\n    count = 0\n    # \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636 */\nint Quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n int) int {\n    count := 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for i := 0; i < n; i++ {\n        for j := 0; j < n; j++ {\n            count++\n        }\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n: Int) -> Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for _ in 0 ..< n {\n        for _ in 0 ..< n {\n            count += 1\n        }\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n  int count = 0;\n  // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n  for (int i = 0; i < n; i++) {\n    for (int j = 0; j < n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e73\u65b9\u9636 */\nfn quadratic(n: i32) -> i32 {\n    let mut count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e73\u65b9\u9636 */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (i in 0..<n) {\n        for (j in 0..<n) {\n            count++\n        }\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{quadratic}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) i32 {\n    var count: i32 = 0;\n    var i: i32 = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    while (i < n) : (i += 1) {\n        var j: i32 = 0;\n        while (j < n) : (j += 1) {\n            count += 1;\n        }\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    The following image compares constant order, linear order, and quadratic order time complexities.

    Figure 2-10 \u00a0 Constant, Linear, and Quadratic Order Time Complexities

    For instance, in bubble sort, the outer loop runs \\(n - 1\\) times, and the inner loop runs \\(n-1\\), \\(n-2\\), ..., \\(2\\), \\(1\\) times, averaging \\(n / 2\\) times, resulting in a time complexity of \\(O((n - 1) n / 2) = O(n^2)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def bubble_sort(nums: list[int]) -> int:\n    \"\"\"\u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\"\"\"\n    count = 0  # \u8ba1\u6570\u5668\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j in range(i):\n            if nums[j] > nums[j + 1]:\n                # \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n    return count\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(vector<int> &nums) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int[] nums) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint BubbleSort(int[] nums) {\n    int count = 0;  // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums []int) int {\n    count := 0 // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j := 0; j < i; j++ {\n            if nums[j] > nums[j+1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums: inout [Int]) -> Int {\n    var count = 0 // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in nums.indices.dropFirst().reversed() {\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\n        for j in 0 ..< i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums) {\n    let count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(List<int> nums) {\n  int count = 0; // \u8ba1\u6570\u5668\n  // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n  for (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\n    for (var j = 0; j < i; j++) {\n      if (nums[j] > nums[j + 1]) {\n        // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n      }\n    }\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfn bubble_sort(nums: &mut [i32]) -> i32 {\n    let mut count = 0; // \u8ba1\u6570\u5668\n\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in (1..nums.len()).rev() {\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\n        for j in 0..i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (i in nums.size - 1 downTo 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\n        for (j in 0..<i) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j] = nums[j + 1].also { nums[j + 1] = nums[j] }\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{bubble_sort}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\nfn bubbleSort(nums: []i32) i32 {\n    var count: i32 = 0;  // \u8ba1\u6570\u5668 \n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    var i: i32 = @as(i32, @intCast(nums.len)) - 1;\n    while (i > 0) : (i -= 1) {\n        var 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\n        while (j < i) : (j += 1) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                var tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_computational_complexity/time_complexity/#4-exponential-order-o2n","title":"4. \u00a0 Exponential Order \\(O(2^n)\\)","text":"

    Biological \"cell division\" is a classic example of exponential order growth: starting with one cell, it becomes two after one division, four after two divisions, and so on, resulting in \\(2^n\\) cells after \\(n\\) divisions.

    The following image and code simulate the cell division process, with a time complexity of \\(O(2^n)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def exponential(n: int) -> int:\n    \"\"\"\u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\n    count = 0\n    base = 1\n    # \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.java
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i < n; i++ {\n        for j := 0; j < base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc exponential(n: Int) -> Int {\n    var count = 0\n    var base = 1\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..< n {\n        for _ in 0 ..< base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i < n; i++) {\n    for (var j = 0; j < base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n
    time_complexity.rs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfn exponential(n: i32) -> i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.kt
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfun exponential(n: Int): Int {\n    var count = 0\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    var base = 1\n    for (i in 0..<n) {\n        for (j in 0..<base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{exponential}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn exponential(n: i32) i32 {\n    var count: i32 = 0;\n    var bas: i32 = 1;\n    var i: i32 = 0;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    while (i < n) : (i += 1) {\n        var j: i32 = 0;\n        while (j < bas) : (j += 1) {\n            count += 1;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    Code Visualization

    Full Screen >

    Figure 2-11 \u00a0 Exponential Order Time Complexity

    In practice, exponential order often appears in recursive functions. For example, in the code below, it recursively splits into two halves, stopping after \\(n\\) divisions:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def exp_recur(n: int) -> int:\n    \"\"\"\u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.java
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return 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) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return 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 {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return 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 {\n    if (n === 1) return 1;\n    return 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) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.rs
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn exp_recur(n: i32) -> i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.kt
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n
    time_complexity.rb
    [class]{}-[func]{exp_recur}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn expRecur(n: i32) i32 {\n    if (n == 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    Code Visualization

    Full Screen >

    Exponential order growth is extremely rapid and is commonly seen in exhaustive search methods (brute force, backtracking, etc.). For large-scale problems, exponential order is unacceptable, often requiring dynamic programming or greedy algorithms as solutions.

    "},{"location":"chapter_computational_complexity/time_complexity/#5-logarithmic-order-olog-n","title":"5. \u00a0 Logarithmic Order \\(O(\\log n)\\)","text":"

    In contrast to exponential order, logarithmic order reflects situations where \"the size is halved each round.\" Given an input data size \\(n\\), since the size is halved each round, the number of iterations is \\(\\log_2 n\\), the inverse function of \\(2^n\\).

    The following image and code simulate the \"halving each round\" process, with a time complexity of \\(O(\\log_2 n)\\), commonly abbreviated as \\(O(\\log n)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def logarithmic(n: int) -> int:\n    \"\"\"\u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\n    count = 0\n    while n > 1:\n        n = n / 2\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc logarithmic(n int) int {\n    count := 0\n    for n > 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc logarithmic(n: Int) -> Int {\n    var count = 0\n    var n = n\n    while n > 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n  int count = 0;\n  while (n > 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfn logarithmic(mut n: i32) -> i32 {\n    let mut count = 0;\n    while n > 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 > 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{logarithmic}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn logarithmic(n: i32) i32 {\n    var count: i32 = 0;\n    var n_var = n;\n    while (n_var > 1)\n    {\n        n_var = n_var / 2;\n        count +=1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    Figure 2-12 \u00a0 Logarithmic Order Time Complexity

    Like exponential order, logarithmic order also frequently appears in recursive functions. The code below forms a recursive tree of height \\(\\log_2 n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def log_recur(n: int) -> int:\n    \"\"\"\u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n <= 1:\n        return 0\n    return log_recur(n / 2) + 1\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint LogRecur(int n) {\n    if (n <= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc logRecur(n int) int {\n    if n <= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc logRecur(n: Int) -> Int {\n    if n <= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n) {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n: number): number {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n  if (n <= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n
    time_complexity.rs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn log_recur(n: i32) -> i32 {\n    if n <= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.kt
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun logRecur(n: Int): Int {\n    if (n <= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n
    time_complexity.rb
    [class]{}-[func]{log_recur}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn logRecur(n: i32) i32 {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    Code Visualization

    Full Screen >

    Logarithmic order is typical in algorithms based on the divide-and-conquer strategy, embodying the \"split into many\" and \"simplify complex problems\" approach. It's slow-growing and is the most ideal time complexity after constant order.

    What is the base of \\(O(\\log n)\\)?

    Technically, \"splitting into \\(m\\)\" corresponds to a time complexity of \\(O(\\log_m n)\\). Using the logarithm base change formula, we can equate different logarithmic complexities:

    \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\]

    This means the base \\(m\\) can be changed without affecting the complexity. Therefore, we often omit the base \\(m\\) and simply denote logarithmic order as \\(O(\\log n)\\).

    "},{"location":"chapter_computational_complexity/time_complexity/#6-linear-logarithmic-order-on-log-n","title":"6. \u00a0 Linear-Logarithmic Order \\(O(n \\log n)\\)","text":"

    Linear-logarithmic order often appears in nested loops, with the complexities of the two loops being \\(O(\\log n)\\) and \\(O(n)\\) respectively. The related code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def linear_log_recur(n: int) -> int:\n    \"\"\"\u7ebf\u6027\u5bf9\u6570\u9636\"\"\"\n    if n <= 1:\n        return 1\n    count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    for _ in range(n):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint LinearLogRecur(int n) {\n    if (n <= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n int) int {\n    if n <= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i < n; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n: Int) -> Int {\n    if n <= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n) {\n    if (n <= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n: number): number {\n    if (n <= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n  if (n <= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i < n; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfn linear_log_recur(n: i32) -> i32 {\n    if n <= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n as i32 {\n        count += 1;\n    }\n    return count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfun linearLogRecur(n: Int): Int {\n    if (n <= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..<n.toInt()) {\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{linear_log_recur}\n
    time_complexity.zig
    // \u7ebf\u6027\u5bf9\u6570\u9636\nfn linearLogRecur(n: i32) i32 {\n    if (n <= 1) return 1;\n    var count: i32 = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    The image below demonstrates how linear-logarithmic order is generated. Each level of a binary tree has \\(n\\) operations, and the tree has \\(\\log_2 n + 1\\) levels, resulting in a time complexity of \\(O(n \\log n)\\).

    Figure 2-13 \u00a0 Linear-Logarithmic Order Time Complexity

    Mainstream sorting algorithms typically have a time complexity of \\(O(n \\log n)\\), such as quicksort, mergesort, and heapsort.

    "},{"location":"chapter_computational_complexity/time_complexity/#7-factorial-order-on","title":"7. \u00a0 Factorial Order \\(O(n!)\\)","text":"

    Factorial order corresponds to the mathematical problem of \"full permutation.\" Given \\(n\\) distinct elements, the total number of possible permutations is:

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

    Factorials are typically implemented using recursion. As shown in the image and code below, the first level splits into \\(n\\) branches, the second level into \\(n - 1\\) branches, and so on, stopping after the \\(n\\)th level:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def factorial_recur(n: int) -> int:\n    \"\"\"\u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n
    time_complexity.cpp
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for i := 0; i < n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n: Int) -> Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in 0 ..< n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n
    time_complexity.js
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (let i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (let i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n  for (var i = 0; i < n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn factorial_recur(n: i32) -> i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n
    time_complexity.c
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (i in 0..<n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{factorial_recur}\n
    time_complexity.zig
    // \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn factorialRecur(n: i32) i32 {\n    if (n == 0) return 1;\n    var count: i32 = 0;\n    var i: i32 = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    while (i < n) : (i += 1) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    Figure 2-14 \u00a0 Factorial Order Time Complexity

    Note that factorial order grows even faster than exponential order; it's unacceptable for larger \\(n\\) values.

    "},{"location":"chapter_computational_complexity/time_complexity/#235-worst-best-and-average-time-complexities","title":"2.3.5 \u00a0 Worst, Best, and Average Time Complexities","text":"

    The time efficiency of an algorithm is often not fixed but depends on the distribution of the input data. Assume we have an array nums of length \\(n\\), consisting of numbers from \\(1\\) to \\(n\\), each appearing only once, but in a randomly shuffled order. The task is to return the index of the element \\(1\\). We can draw the following conclusions:

    • When nums = [?, ?, ..., 1], that is, when the last element is \\(1\\), it requires a complete traversal of the array, achieving the worst-case time complexity of \\(O(n)\\).
    • When nums = [1, ?, ?, ...], that is, when the first element is \\(1\\), no matter the length of the array, no further traversal is needed, achieving the best-case time complexity of \\(\\Omega(1)\\).

    The \"worst-case time complexity\" corresponds to the asymptotic upper bound, denoted by the big \\(O\\) notation. Correspondingly, the \"best-case time complexity\" corresponds to the asymptotic lower bound, denoted by \\(\\Omega\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    nums = [i for i in range(1, n + 1)]\n    # \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -> int:\n    \"\"\"\u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\"\"\"\n    for 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)\n        if nums[i] == 1:\n            return i\n    return -1\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) {\n    vector<int> nums(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u4f7f\u7528\u7cfb\u7edf\u65f6\u95f4\u751f\u6210\u968f\u673a\u79cd\u5b50\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(vector<int> &nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n
    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) {\n    Integer[] nums = new Integer[n];\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -> int[]\n    int[] res = new int[n];\n    for (int i = 0; i < n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int[] nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -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) {\n    int[] nums = new int[n];\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (int i = 0; i < nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint FindOne(int[] nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\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 {\n    nums := make([]int, n)\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for i := 0; i < n; i++ {\n        nums[i] = i + 1\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums []int) int {\n    for 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)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -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 }\n    var nums = Array(1 ... n)\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    nums.shuffle()\n    return nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums: [Int]) -> Int {\n    for 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)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -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) {\n    const nums = Array(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (let i = 0; i < n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums) {\n    for (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)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -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[] {\n    const nums = Array(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (let i = 0; i < n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums: number[]): number {\n    for (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)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -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) {\n  final nums = List.filled(n, 0);\n  // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i < n; i++) {\n    nums[i] = i + 1;\n  }\n  // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n  nums.shuffle();\n\n  return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(List<int> nums) {\n  for (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)\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n
    worst_best_time_complexity.rs
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfn random_numbers(n: i32) -> Vec<i32> {\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::<Vec<i32>>();\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    nums.shuffle(&mut thread_rng());\n    nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfn find_one(nums: &[i32]) -> Option<usize> {\n    for i in 0..nums.len() {\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)\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\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\u4e3a n \uff0c\u5143\u7d20\u7c7b\u578b\u4e3a int \uff09\n    int *nums = (int *)malloc(n * sizeof(int));\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (int i = n - 1; i > 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int *nums, int n) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n
    worst_best_time_complexity.kt
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfun randomNumbers(n: Int): Array<Int?> {\n    val nums = IntArray(n)\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (i in 0..<n) {\n        nums[i] = i + 1\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    val mutableList = nums.toMutableList()\n    mutableList.shuffle()\n    // Integer[] -> int[]\n    val res = arrayOfNulls<Int>(n)\n    for (i in 0..<n) {\n        res[i] = mutableList[i]\n    }\n    return res\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfun findOne(nums: Array<Int?>): Int {\n    for (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)\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n
    worst_best_time_complexity.rb
    [class]{}-[func]{random_numbers}\n\n[class]{}-[func]{find_one}\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\nfn randomNumbers(comptime n: usize) [n]i32 {\n    var nums: [n]i32 = undefined;\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (&nums, 0..) |*num, i| {\n        num.* = @as(i32, @intCast(i)) + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    const rand = std.crypto.random;\n    rand.shuffle(i32, &nums);\n    return nums;\n}\n\n// \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\nfn findOne(nums: []i32) i32 {\n    for (nums, 0..) |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)\n        if (num == 1) return @intCast(i);\n    }\n    return -1;\n}\n
    Code Visualization

    Full Screen >

    It's important to note that the best-case time complexity is rarely used in practice, as it is usually only achievable under very low probabilities and might be misleading. The worst-case time complexity is more practical as it provides a safety value for efficiency, allowing us to confidently use the algorithm.

    From the above example, it's clear that both the worst-case and best-case time complexities only occur under \"special data distributions,\" which may have a small probability of occurrence and may not accurately reflect the algorithm's run efficiency. In contrast, the average time complexity can reflect the algorithm's efficiency under random input data, denoted by the \\(\\Theta\\) notation.

    For some algorithms, we can simply estimate the average case under a random data distribution. For example, in the aforementioned example, since the input array is shuffled, the probability of element \\(1\\) appearing at any index is equal. Therefore, the average number of loops for the algorithm is half the length of the array \\(n / 2\\), giving an average time complexity of \\(\\Theta(n / 2) = \\Theta(n)\\).

    However, calculating the average time complexity for more complex algorithms can be quite difficult, as it's challenging to analyze the overall mathematical expectation under the data distribution. In such cases, we usually use the worst-case time complexity as the standard for judging the efficiency of the algorithm.

    Why is the \\(\\Theta\\) symbol rarely seen?

    Possibly because the \\(O\\) notation is more commonly spoken, it is often used to represent the average time complexity. However, strictly speaking, this practice is not accurate. In this book and other materials, if you encounter statements like \"average time complexity \\(O(n)\\)\", please understand it directly as \\(\\Theta(n)\\).

    "},{"location":"chapter_data_structure/","title":"Chapter 3. \u00a0 Data Structures","text":"

    Abstract

    Data structures serve as a robust and diverse framework.

    They offer a blueprint for the orderly organization of data, upon which algorithms come to life.

    "},{"location":"chapter_data_structure/#chapter-contents","title":"Chapter Contents","text":"
    • 3.1 \u00a0 Classification of Data Structures
    • 3.2 \u00a0 Fundamental Data Types
    • 3.3 \u00a0 Number Encoding *
    • 3.4 \u00a0 Character Encoding *
    • 3.5 \u00a0 Summary
    "},{"location":"chapter_data_structure/basic_data_types/","title":"3.2 \u00a0 Basic Data Types","text":"

    When discussing data in computers, various forms like text, images, videos, voice and 3D models comes to mind. Despite their different organizational forms, they are all composed of various basic data types.

    Basic data types are those that the CPU can directly operate on and are directly used in algorithms, mainly including the following.

    • Integer types: byte, short, int, long.
    • Floating-point types: float, double, used to represent decimals.
    • Character type: char, used to represent letters, punctuation, and even emojis in various languages.
    • Boolean type: bool, used to represent \"yes\" or \"no\" decisions.

    Basic data types are stored in computers in binary form. One binary digit is 1 bit. In most modern operating systems, 1 byte consists of 8 bits.

    The range of values for basic data types depends on the size of the space they occupy. Below, we take Java as an example.

    • The integer type byte occupies 1 byte = 8 bits and can represent \\(2^8\\) numbers.
    • The integer type int occupies 4 bytes = 32 bits and can represent \\(2^{32}\\) numbers.

    The following table lists the space occupied, value range, and default values of various basic data types in Java. While memorizing this table isn't necessary, having a general understanding of it and referencing it when required is recommended.

    Table 3-1 \u00a0 Space Occupied and Value Range of Basic Data Types

    Type Symbol Space Occupied Minimum Value Maximum Value Default Value Integer 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 Float float 4 bytes \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) double 8 bytes \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) 0.0 Char char 2 bytes 0 \\(2^{16} - 1\\) 0 Boolean bool 1 byte \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\)

    Please note that the above table is specific to Java's basic data types. Every programming language has its own data type definitions, which might differ in space occupied, value ranges, and default values.

    • In Python, the integer type int can be of any size, limited only by available memory; the floating-point float is double precision 64-bit; there is no char type, as a single character is actually a string str of length 1.
    • C and C++ do not specify the size of basic data types, it varies with implementation and platform. The above table follows the LP64 data model, used for Unix 64-bit operating systems including Linux and macOS.
    • The size of char in C and C++ is 1 byte, while in most programming languages, it depends on the specific character encoding method, as detailed in the \"Character Encoding\" chapter.
    • Even though representing a boolean only requires 1 bit (0 or 1), it is usually stored in memory as 1 byte. This is because modern computer CPUs typically use 1 byte as the smallest addressable memory unit.

    So, what is the connection between basic data types and data structures? We know that data structures are ways to organize and store data in computers. The focus here is on \"structure\" rather than \"data\".

    If we want to represent \"a row of numbers\", we naturally think of using an array. This is because the linear structure of an array can represent the adjacency and the ordering of the numbers, but whether the stored content is an integer int, a decimal float, or a character char, is irrelevant to the \"data structure\".

    In other words, basic data types provide the \"content type\" of data, while data structures provide the \"way of organizing\" data. For example, in the following code, we use the same data structure (array) to store and represent different basic data types, including int, float, char, bool, etc.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    # Using various basic data types to initialize arrays\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# Python's characters are actually strings of length 1\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python's lists can freely store various basic data types and object references\ndata = [0, 0.0, 'a', False, ListNode(0)]\n
    // Using various basic data types to initialize arrays\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n
    // Using various basic data types to initialize arrays\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n
    // Using various basic data types to initialize arrays\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n
    // Using various basic data types to initialize arrays\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n
    // Using various basic data types to initialize arrays\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n
    // JavaScript's arrays can freely store various basic data types and objects\nconst array = [0, 0.0, 'a', false];\n
    // Using various basic data types to initialize arrays\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n
    // Using various basic data types to initialize arrays\nList<int> numbers = List.filled(5, 0);\nList<double> decimals = List.filled(5, 0.0);\nList<String> characters = List.filled(5, 'a');\nList<bool> bools = List.filled(5, false);\n
    // Using various basic data types to initialize arrays\nlet numbers: Vec<i32> = vec![0; 5];\nlet decimals: Vec<f32> = vec![0.0, 5];\nlet characters: Vec<char> = vec!['0'; 5];\nlet bools: Vec<bool> = vec![false; 5];\n
    // Using various basic data types to initialize arrays\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n
    \n
    // Using various basic data types to initialize arrays\nvar numbers: [5]i32 = undefined;\nvar decimals: [5]f32 = undefined;\nvar characters: [5]u8 = undefined;\nvar bools: [5]bool = undefined;\n
    "},{"location":"chapter_data_structure/character_encoding/","title":"3.4 \u00a0 Character Encoding *","text":"

    In the computer system, all data is stored in binary form, and characters (represented by char) are no exception. To represent characters, we need to develop a \"character set\" that defines a one-to-one mapping between each character and binary numbers. With the character set, computers can convert binary numbers to characters by looking up the table.

    "},{"location":"chapter_data_structure/character_encoding/#341-ascii-character-set","title":"3.4.1 \u00a0 ASCII Character Set","text":"

    The \"ASCII code\" is one of the earliest character sets, officially known as the American Standard Code for Information Interchange. It uses 7 binary digits (the lower 7 bits of a byte) to represent a character, allowing for a maximum of 128 different characters. As shown in the Figure 3-6 , ASCII includes uppercase and lowercase English letters, numbers 0 ~ 9, various punctuation marks, and certain control characters (such as newline and tab).

    Figure 3-6 \u00a0 ASCII Code

    However, ASCII can only represent English characters. With the globalization of computers, a character set called \"EASCII\" was developed to represent more languages. It expands from the 7-bit structure of ASCII to 8 bits, enabling the representation of 256 characters.

    Globally, various region-specific EASCII character sets have been introduced. The first 128 characters of these sets are consistent with the ASCII, while the remaining 128 characters are defined differently to accommodate the requirements of different languages.

    "},{"location":"chapter_data_structure/character_encoding/#342-gbk-character-set","title":"3.4.2 \u00a0 GBK Character Set","text":"

    Later, it was found that EASCII still could not meet the character requirements of many languages. For instance, there are nearly a hundred thousand Chinese characters, with several thousand used regularly. In 1980, the Standardization Administration of China released the \"GB2312\" character set, which included 6763 Chinese characters, essentially fulfilling the computer processing needs for the Chinese language.

    However, GB2312 could not handle some rare and traditional characters. The \"GBK\" character set expands GB2312 and includes 21886 Chinese characters. In the GBK encoding scheme, ASCII characters are represented with one byte, while Chinese characters use two bytes.

    "},{"location":"chapter_data_structure/character_encoding/#343-unicode-character-set","title":"3.4.3 \u00a0 Unicode Character Set","text":"

    With the rapid evolution of computer technology and a plethora of character sets and encoding standards, numerous problems arose. On the one hand, these character sets generally only defined characters for specific languages and could not function properly in multilingual environments. On the other hand, the existence of multiple character set standards for the same language caused garbled text when information was exchanged between computers using different encoding standards.

    Researchers of that era thought: What if a comprehensive character set encompassing all global languages and symbols was developed? Wouldn't this resolve the issues associated with cross-linguistic environments and garbled text? Inspired by this idea, the extensive character set, Unicode, was born.

    \"Unicode\" is referred to as \"\u7edf\u4e00\u7801\" (Unified Code) in Chinese, theoretically capable of accommodating over a million characters. It aims to incorporate characters from all over the world into a single set, providing a universal character set for processing and displaying various languages and reducing the issues of garbled text due to different encoding standards.

    Since its release in 1991, Unicode has continually expanded to include new languages and characters. As of September 2022, Unicode contains 149,186 characters, including characters, symbols, and even emojis from various languages. In the vast Unicode character set, commonly used characters occupy 2 bytes, while some rare characters may occupy 3 or even 4 bytes.

    Unicode is a universal character set that assigns a number (called a \"code point\") to each character, but it does not specify how these character code points should be stored in a computer system. One might ask: How does a system interpret Unicode code points of varying lengths within a text? For example, given a 2-byte code, how does the system determine if it represents a single 2-byte character or two 1-byte characters?

    A straightforward solution to this problem is to store all characters as equal-length encodings. As shown in the Figure 3-7 , each character in \"Hello\" occupies 1 byte, while each character in \"\u7b97\u6cd5\" (algorithm) occupies 2 bytes. We could encode all characters in \"Hello \u7b97\u6cd5\" as 2 bytes by padding the higher bits with zeros. This method would enable the system to interpret a character every 2 bytes, recovering the content of the phrase.

    Figure 3-7 \u00a0 Unicode Encoding Example

    However, as ASCII has shown us, encoding English only requires 1 byte. Using the above approach would double the space occupied by English text compared to ASCII encoding, which is a waste of memory space. Therefore, a more efficient Unicode encoding method is needed.

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

    Currently, UTF-8 has become the most widely used Unicode encoding method internationally. It is a variable-length encoding, using 1 to 4 bytes to represent a character, depending on the complexity of the character. ASCII characters need only 1 byte, Latin and Greek letters require 2 bytes, commonly used Chinese characters need 3 bytes, and some other rare characters need 4 bytes.

    The encoding rules for UTF-8 are not complex and can be divided into two cases:

    • For 1-byte characters, set the highest bit to \\(0\\), and the remaining 7 bits to the Unicode code point. Notably, ASCII characters occupy the first 128 code points in the Unicode set. This means that UTF-8 encoding is backward compatible with ASCII. This implies that UTF-8 can be used to parse ancient ASCII text.
    • For characters of length \\(n\\) bytes (where \\(n > 1\\)), set the highest \\(n\\) bits of the first byte to \\(1\\), and the \\((n + 1)^{\\text{th}}\\) bit to \\(0\\); starting from the second byte, set the highest 2 bits of each byte to \\(10\\); the rest of the bits are used to fill the Unicode code point.

    The Figure 3-8 shows the UTF-8 encoding for \"Hello\u7b97\u6cd5\". It can be observed that since the highest \\(n\\) bits are set to \\(1\\), the system can determine the length of the character as \\(n\\) by counting the number of highest bits set to \\(1\\).

    But why set the highest 2 bits of the remaining bytes to \\(10\\)? Actually, this \\(10\\) serves as a kind of checksum. If the system starts parsing text from an incorrect byte, the \\(10\\) at the beginning of the byte can help the system quickly detect anomalies.

    The reason for using \\(10\\) as a checksum is that, under UTF-8 encoding rules, it's impossible for the highest two bits of a character to be \\(10\\). This can be proven by contradiction: If the highest two bits of a character are \\(10\\), it indicates that the character's length is \\(1\\), corresponding to ASCII. However, the highest bit of an ASCII character should be \\(0\\), which contradicts the assumption.

    Figure 3-8 \u00a0 UTF-8 Encoding Example

    Apart from UTF-8, other common encoding methods include:

    • UTF-16 Encoding: Uses 2 or 4 bytes to represent a character. All ASCII characters and commonly used non-English characters are represented with 2 bytes; a few characters require 4 bytes. For 2-byte characters, the UTF-16 encoding equals the Unicode code point.
    • UTF-32 Encoding: Every character uses 4 bytes. This means UTF-32 occupies more space than UTF-8 and UTF-16, especially for texts with a high proportion of ASCII characters.

    From the perspective of storage space, using UTF-8 to represent English characters is very efficient because it only requires 1 byte; using UTF-16 to encode some non-English characters (such as Chinese) can be more efficient because it only requires 2 bytes, while UTF-8 might need 3 bytes.

    From a compatibility perspective, UTF-8 is the most versatile, with many tools and libraries supporting UTF-8 as a priority.

    "},{"location":"chapter_data_structure/character_encoding/#345-character-encoding-in-programming-languages","title":"3.4.5 \u00a0 Character Encoding in Programming Languages","text":"

    Historically, many programming languages utilized fixed-length encodings such as UTF-16 or UTF-32 for processing strings during program execution. This allows strings to be handled as arrays, offering several advantages:

    • Random Access: Strings encoded in UTF-16 can be accessed randomly with ease. For UTF-8, which is a variable-length encoding, locating the \\(i^{th}\\) character requires traversing the string from the start to the \\(i^{th}\\) position, taking \\(O(n)\\) time.
    • Character Counting: Similar to random access, counting the number of characters in a UTF-16 encoded string is an \\(O(1)\\) operation. However, counting characters in a UTF-8 encoded string requires traversing the entire string.
    • String Operations: Many string operations like splitting, concatenating, inserting, and deleting are easier on UTF-16 encoded strings. These operations generally require additional computation on UTF-8 encoded strings to ensure the validity of the UTF-8 encoding.

    The design of character encoding schemes in programming languages is an interesting topic involving various factors:

    • Java\u2019s String type uses UTF-16 encoding, with each character occupying 2 bytes. This was based on the initial belief that 16 bits were sufficient to represent all possible characters and proven incorrect later. As the Unicode standard expanded beyond 16 bits, characters in Java may now be represented by a pair of 16-bit values, known as \u201csurrogate pairs.\u201d
    • JavaScript and TypeScript use UTF-16 encoding for similar reasons as Java. When JavaScript was first introduced by Netscape in 1995, Unicode was still in its early stages, and 16-bit encoding was sufficient to represent all Unicode characters.
    • C# uses UTF-16 encoding, largely because the .NET platform, designed by Microsoft, and many Microsoft technologies, including the Windows operating system, extensively use UTF-16 encoding.

    Due to the underestimation of character counts, these languages had to use \"surrogate pairs\" to represent Unicode characters exceeding 16 bits. This approach has its drawbacks: strings containing surrogate pairs may have characters occupying 2 or 4 bytes, losing the advantage of fixed-length encoding. Additionally, handling surrogate pairs adds complexity and debugging difficulty to programming.

    Addressing these challenges, some languages have adopted alternative encoding strategies:

    • Python\u2019s str type uses Unicode encoding with a flexible representation where the storage length of characters depends on the largest Unicode code point in the string. If all characters are ASCII, each character occupies 1 byte, 2 bytes for characters within the Basic Multilingual Plane (BMP), and 4 bytes for characters beyond the BMP.
    • Go\u2019s string type internally uses UTF-8 encoding. Go also provides the rune type for representing individual Unicode code points.
    • Rust\u2019s str and String types use UTF-8 encoding internally. Rust also offers the char type for individual Unicode code points.

    It\u2019s important to note that the above discussion pertains to how strings are stored in programming languages, which is different from how strings are stored in files or transmitted over networks. For file storage or network transmission, strings are usually encoded in UTF-8 format for optimal compatibility and space efficiency.

    "},{"location":"chapter_data_structure/classification_of_data_structure/","title":"3.1 \u00a0 Classification of Data Structures","text":"

    Common data structures include arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs. They can be classified into \"logical structure\" and \"physical structure\".

    "},{"location":"chapter_data_structure/classification_of_data_structure/#311-logical-structure-linear-and-non-linear","title":"3.1.1 \u00a0 Logical Structure: Linear and Non-Linear","text":"

    The logical structures reveal the logical relationships between data elements. In arrays and linked lists, data are arranged in a specific sequence, demonstrating the linear relationship between data; while in trees, data are arranged hierarchically from the top down, showing the derived relationship between \"ancestors\" and \"descendants\"; and graphs are composed of nodes and edges, reflecting the intricate network relationship.

    As shown in the Figure 3-1 , logical structures can be divided into two major categories: \"linear\" and \"non-linear\". Linear structures are more intuitive, indicating data is arranged linearly in logical relationships; non-linear structures, conversely, are arranged non-linearly.

    • Linear Data Structures: Arrays, Linked Lists, Stacks, Queues, Hash Tables.
    • Non-Linear Data Structures: Trees, Heaps, Graphs, Hash Tables.

    Figure 3-1 \u00a0 Linear and Non-Linear Data Structures

    Non-linear data structures can be further divided into tree structures and network structures.

    • Linear Structures: Arrays, linked lists, queues, stacks, and hash tables, where elements have a one-to-one sequential relationship.
    • Tree Structures: Trees, Heaps, Hash Tables, where elements have a one-to-many relationship.
    • Network Structures: Graphs, where elements have a many-to-many relationships.
    "},{"location":"chapter_data_structure/classification_of_data_structure/#312-physical-structure-contiguous-and-dispersed","title":"3.1.2 \u00a0 Physical Structure: Contiguous and Dispersed","text":"

    During the execution of an algorithm, the data being processed is stored in memory. The Figure 3-2 shows a computer memory stick where each black square is a physical memory space. We can think of memory as a vast Excel spreadsheet, with each cell capable of storing a certain amount of data.

    The system accesses the data at the target location by means of a memory address. As shown in the Figure 3-2 , the computer assigns a unique identifier to each cell in the table according to specific rules, ensuring that each memory space has a unique memory address. With these addresses, the program can access the data stored in memory.

    Figure 3-2 \u00a0 Memory Stick, Memory Spaces, Memory Addresses

    Tip

    It's worth noting that comparing memory to an Excel spreadsheet is a simplified analogy. The actual working mechanism of memory is more complex, involving concepts like address space, memory management, cache mechanisms, virtual memory, and physical memory.

    Memory is a shared resource for all programs. When a block of memory is occupied by one program, it cannot be simultaneously used by other programs. Therefore, considering memory resources is crucial in designing data structures and algorithms. For instance, the algorithm's peak memory usage should not exceed the remaining free memory of the system; if there is a lack of contiguous memory blocks, then the data structure chosen must be able to be stored in non-contiguous memory blocks.

    As illustrated in the Figure 3-3 , the physical structure reflects the way data is stored in computer memory and it can be divided into contiguous space storage (arrays) and non-contiguous space storage (linked lists). The two types of physical structures exhibit complementary characteristics in terms of time efficiency and space efficiency.

    Figure 3-3 \u00a0 Contiguous Space Storage and Dispersed Space Storage

    It is worth noting that all data structures are implemented based on arrays, linked lists, or a combination of both. For example, stacks and queues can be implemented using either arrays or linked lists; while implementations of hash tables may involve both arrays and linked lists. - Array-based implementations: Stacks, Queues, Hash Tables, Trees, Heaps, Graphs, Matrices, Tensors (arrays with dimensions \\(\\geq 3\\)). - Linked-list-based implementations: Stacks, Queues, Hash Tables, Trees, Heaps, Graphs, etc.

    Data structures implemented based on arrays are also called \u201cStatic Data Structures,\u201d meaning their length cannot be changed after initialization. Conversely, those based on linked lists are called \u201cDynamic Data Structures,\u201d which can still adjust their size during program execution.

    Tip

    If you find it challenging to comprehend the physical structure, it is recommended that you read the next chapter, \"Arrays and Linked Lists,\" and revisit this section later.

    "},{"location":"chapter_data_structure/number_encoding/","title":"3.3 \u00a0 Number Encoding *","text":"

    Note

    In this book, chapters marked with an asterisk '*' are optional readings. If you are short on time or find them challenging, you may skip these initially and return to them after completing the essential chapters.

    "},{"location":"chapter_data_structure/number_encoding/#331-integer-encoding","title":"3.3.1 \u00a0 Integer Encoding","text":"

    In the table from the previous section, we observed that all integer types can represent one more negative number than positive numbers, such as the byte range of \\([-128, 127]\\). This phenomenon seems counterintuitive, and its underlying reason involves knowledge of sign-magnitude, one's complement, and two's complement encoding.

    Firstly, it's important to note that numbers are stored in computers using the two's complement form. Before analyzing why this is the case, let's define these three encoding methods:

    • Sign-magnitude: The highest bit of a binary representation of a number is considered the sign bit, where \\(0\\) represents a positive number and \\(1\\) represents a negative number. The remaining bits represent the value of the number.
    • One's complement: The one's complement of a positive number is the same as its sign-magnitude. For negative numbers, it's obtained by inverting all bits except the sign bit.
    • Two's complement: The two's complement of a positive number is the same as its sign-magnitude. For negative numbers, it's obtained by adding \\(1\\) to their one's complement.

    The following diagram illustrates the conversions among sign-magnitude, one's complement, and two's complement:

    Figure 3-4 \u00a0 Conversions between Sign-Magnitude, One's Complement, and Two's Complement

    Although sign-magnitude is the most intuitive, it has limitations. For one, negative numbers in sign-magnitude cannot be directly used in calculations. For example, in sign-magnitude, calculating \\(1 + (-2)\\) results in \\(-3\\), which is incorrect.

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

    To address this, computers introduced the one's complement. If we convert to one's complement and calculate \\(1 + (-2)\\), then convert the result back to sign-magnitude, we get the correct result of \\(-1\\).

    \\[ \\begin{aligned} & 1 + (-2) \\newline & \\rightarrow 0000 \\; 0001 \\; \\text{(Sign-magnitude)} + 1000 \\; 0010 \\; \\text{(Sign-magnitude)} \\newline & = 0000 \\; 0001 \\; \\text{(One's complement)} + 1111 \\; 1101 \\; \\text{(One's complement)} \\newline & = 1111 \\; 1110 \\; \\text{(One's complement)} \\newline & = 1000 \\; 0001 \\; \\text{(Sign-magnitude)} \\newline & \\rightarrow -1 \\end{aligned} \\]

    Additionally, there are two representations of zero in sign-magnitude: \\(+0\\) and \\(-0\\). This means two different binary encodings for zero, which could lead to ambiguity. For example, in conditional checks, not differentiating between positive and negative zero might result in incorrect outcomes. Addressing this ambiguity would require additional checks, potentially reducing computational efficiency.

    \\[ \\begin{aligned} +0 & \\rightarrow 0000 \\; 0000 \\newline -0 & \\rightarrow 1000 \\; 0000 \\end{aligned} \\]

    Like sign-magnitude, one's complement also suffers from the positive and negative zero ambiguity. Therefore, computers further introduced the two's complement. Let's observe the conversion process for negative zero in sign-magnitude, one's complement, and two's complement:

    \\[ \\begin{aligned} -0 \\rightarrow \\; & 1000 \\; 0000 \\; \\text{(Sign-magnitude)} \\newline = \\; & 1111 \\; 1111 \\; \\text{(One's complement)} \\newline = 1 \\; & 0000 \\; 0000 \\; \\text{(Two's complement)} \\newline \\end{aligned} \\]

    Adding \\(1\\) to the one's complement of negative zero produces a carry, but with byte length being only 8 bits, the carried-over \\(1\\) to the 9th bit is discarded. Therefore, the two's complement of negative zero is \\(0000 \\; 0000\\), the same as positive zero, thus resolving the ambiguity.

    One last puzzle is the \\([-128, 127]\\) range for byte, with an additional negative number, \\(-128\\). We observe that for the interval \\([-127, +127]\\), all integers have corresponding sign-magnitude, one's complement, and two's complement, allowing for mutual conversion between them.

    However, the two's complement \\(1000 \\; 0000\\) is an exception without a corresponding sign-magnitude. According to the conversion method, its sign-magnitude would be \\(0000 \\; 0000\\), indicating zero. This presents a contradiction because its two's complement should represent itself. Computers designate this special two's complement \\(1000 \\; 0000\\) as representing \\(-128\\). In fact, the calculation of \\((-1) + (-127)\\) in two's complement results in \\(-128\\).

    \\[ \\begin{aligned} & (-127) + (-1) \\newline & \\rightarrow 1111 \\; 1111 \\; \\text{(Sign-magnitude)} + 1000 \\; 0001 \\; \\text{(Sign-magnitude)} \\newline & = 1000 \\; 0000 \\; \\text{(One's complement)} + 1111 \\; 1110 \\; \\text{(One's complement)} \\newline & = 1000 \\; 0001 \\; \\text{(Two's complement)} + 1111 \\; 1111 \\; \\text{(Two's complement)} \\newline & = 1000 \\; 0000 \\; \\text{(Two's complement)} \\newline & \\rightarrow -128 \\end{aligned} \\]

    As you might have noticed, all these calculations are additions, hinting at an important fact: computers' internal hardware circuits are primarily designed around addition operations. This is because addition is simpler to implement in hardware compared to other operations like multiplication, division, and subtraction, allowing for easier parallelization and faster computation.

    It's important to note that this doesn't mean computers can only perform addition. By combining addition with basic logical operations, computers can execute a variety of other mathematical operations. For example, the subtraction \\(a - b\\) can be translated into \\(a + (-b)\\); multiplication and division can be translated into multiple additions or subtractions.

    We can now summarize the reason for using two's complement in computers: with two's complement representation, computers can use the same circuits and operations to handle both positive and negative number addition, eliminating the need for special hardware circuits for subtraction and avoiding the ambiguity of positive and negative zero. This greatly simplifies hardware design and enhances computational efficiency.

    The design of two's complement is quite ingenious, and due to space constraints, we'll stop here. Interested readers are encouraged to explore further.

    "},{"location":"chapter_data_structure/number_encoding/#332-floating-point-number-encoding","title":"3.3.2 \u00a0 Floating-Point Number Encoding","text":"

    You might have noticed something intriguing: despite having the same length of 4 bytes, why does a float have a much larger range of values compared to an int? This seems counterintuitive, as one would expect the range to shrink for float since it needs to represent fractions.

    In fact, this is due to the different representation method used by floating-point numbers (float). Let's consider a 32-bit binary number as:

    \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\]

    According to the IEEE 754 standard, a 32-bit float consists of the following three parts:

    • Sign bit \\(\\mathrm{S}\\): Occupies 1 bit, corresponding to \\(b_{31}\\).
    • Exponent bit \\(\\mathrm{E}\\): Occupies 8 bits, corresponding to \\(b_{30} b_{29} \\ldots b_{23}\\).
    • Fraction bit \\(\\mathrm{N}\\): Occupies 23 bits, corresponding to \\(b_{22} b_{21} \\ldots b_0\\).

    The value of a binary float number is calculated as:

    \\[ \\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 \\]

    Converted to a decimal formula, this becomes:

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

    The range of each component is:

    \\[ \\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} \\times 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\]

    Figure 3-5 \u00a0 Example Calculation of a float in IEEE 754 Standard

    Observing the diagram, given an example data \\(\\mathrm{S} = 0\\), \\(\\mathrm{E} = 124\\), \\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\), we have:

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

    Now we can answer the initial question: The representation of float includes an exponent bit, leading to a much larger range than int. Based on the above calculation, the maximum positive number representable by float is approximately \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\), and the minimum negative number is obtained by switching the sign bit.

    However, the trade-off for float's expanded range is a sacrifice in precision. The integer type int uses all 32 bits to represent the number, with values evenly distributed; but due to the exponent bit, the larger the value of a float, the greater the difference between adjacent numbers.

    As shown in the Table 3-2 , exponent bits \\(E = 0\\) and \\(E = 255\\) have special meanings, used to represent zero, infinity, \\(\\mathrm{NaN}\\), etc.

    Table 3-2 \u00a0 Meaning of Exponent Bits

    Exponent Bit E Fraction Bit \\(\\mathrm{N} = 0\\) Fraction Bit \\(\\mathrm{N} \\ne 0\\) Calculation Formula \\(0\\) \\(\\pm 0\\) Subnormal Numbers \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) Normal Numbers Normal Numbers \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\)

    It's worth noting that subnormal numbers significantly improve the precision of floating-point numbers. The smallest positive normal number is \\(2^{-126}\\), and the smallest positive subnormal number is \\(2^{-126} \\times 2^{-23}\\).

    Double-precision double also uses a similar representation method to float, which is not elaborated here for brevity.

    "},{"location":"chapter_data_structure/summary/","title":"3.5 \u00a0 Summary","text":""},{"location":"chapter_data_structure/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"
    • Data structures can be categorized from two perspectives: logical structure and physical structure. Logical structure describes the logical relationships between data elements, while physical structure describes how data is stored in computer memory.
    • Common logical structures include linear, tree-like, and network structures. We generally classify data structures into linear (arrays, linked lists, stacks, queues) and non-linear (trees, graphs, heaps) based on their logical structure. The implementation of hash tables may involve both linear and non-linear data structures.
    • When a program runs, data is stored in computer memory. Each memory space has a corresponding memory address, and the program accesses data through these addresses.
    • Physical structures are primarily divided into contiguous space storage (arrays) and dispersed space storage (linked lists). All data structures are implemented using arrays, linked lists, or a combination of both.
    • Basic data types in computers include integers (byte, short, int, long), floating-point numbers (float, double), characters (char), and booleans (boolean). Their range depends on the size of the space occupied and the representation method.
    • Original code, complement code, and two's complement code are three methods of encoding numbers in computers, and they can be converted into each other. The highest bit of the original code of an integer is the sign bit, and the remaining bits represent the value of the number.
    • Integers are stored in computers in the form of two's complement. In this representation, the computer can treat the addition of positive and negative numbers uniformly, without the need for special hardware circuits for subtraction, and there is no ambiguity of positive and negative zero.
    • The encoding of floating-point numbers consists of 1 sign bit, 8 exponent bits, and 23 fraction bits. Due to the presence of the exponent bit, the range of floating-point numbers is much greater than that of integers, but at the cost of sacrificing precision.
    • ASCII is the earliest English character set, 1 byte in length, and includes 127 characters. The GBK character set is a commonly used Chinese character set, including more than 20,000 Chinese characters. Unicode strives to provide a complete character set standard, including characters from various languages worldwide, thus solving the problem of garbled characters caused by inconsistent character encoding methods.
    • UTF-8 is the most popular Unicode encoding method, with excellent universality. It is a variable-length encoding method with good scalability and effectively improves the efficiency of space usage. UTF-16 and UTF-32 are fixed-length encoding methods. When encoding Chinese characters, UTF-16 occupies less space than UTF-8. Programming languages like Java and C# use UTF-16 encoding by default.
    "},{"location":"chapter_data_structure/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Why does a hash table contain both linear and non-linear data structures?

    The underlying structure of a hash table is an array. To resolve hash collisions, we may use \"chaining\": each bucket in the array points to a linked list, which, when exceeding a certain threshold, might be transformed into a tree (usually a red-black tree). From a storage perspective, the foundation of a hash table is an array, where each bucket slot might contain a value, a linked list, or a tree. Therefore, hash tables may contain both linear data structures (arrays, linked lists) and non-linear data structures (trees).

    Q: Is the length of the char type 1 byte?

    The length of the char type is determined by the encoding method used by the programming language. For example, Java, JavaScript, TypeScript, and C# all use UTF-16 encoding (to save Unicode code points), so the length of the char type is 2 bytes.

    Q: Is there ambiguity in calling data structures based on arrays \"static data structures\"? Because operations like push and pop on stacks are \"dynamic\".

    While stacks indeed allow for dynamic data operations, the data structure itself remains \"static\" (with unchangeable length). Even though data structures based on arrays can dynamically add or remove elements, their capacity is fixed. If the data volume exceeds the pre-allocated size, a new, larger array needs to be created, and the contents of the old array copied into it.

    Q: When building stacks (queues) without specifying their size, why are they considered \"static data structures\"?

    In high-level programming languages, we don't need to manually specify the initial capacity of stacks (queues); this task is automatically handled internally by the class. For example, the initial capacity of Java's ArrayList is usually 10. Furthermore, the expansion operation is also implemented automatically. See the subsequent \"List\" chapter for details.

    "},{"location":"chapter_hashing/","title":"Chapter 6. \u00a0 Hash Table","text":"

    Abstract

    In the world of computing, a hash table is akin to an intelligent librarian.

    It understands how to compute index numbers, enabling swift retrieval of the desired book.

    "},{"location":"chapter_hashing/#chapter-contents","title":"Chapter Contents","text":"
    • 6.1 \u00a0 Hash Table
    • 6.2 \u00a0 Hash Collision
    • 6.3 \u00a0 Hash Algorithm
    • 6.4 \u00a0 Summary
    "},{"location":"chapter_hashing/hash_algorithm/","title":"6.3 \u00a0 Hash Algorithms","text":"

    The previous two sections introduced the working principle of hash tables and the methods to handle hash collisions. However, both open addressing and chaining can only ensure that the hash table functions normally when collisions occur, but cannot reduce the frequency of hash collisions.

    If hash collisions occur too frequently, the performance of the hash table will deteriorate drastically. As shown in the Figure 6-8 , for a chaining hash table, in the ideal case, the key-value pairs are evenly distributed across the buckets, achieving optimal query efficiency; in the worst case, all key-value pairs are stored in the same bucket, degrading the time complexity to \\(O(n)\\).

    Figure 6-8 \u00a0 Ideal and Worst Cases of Hash Collisions

    The distribution of key-value pairs is determined by the hash function. Recalling the steps of calculating a hash function, first compute the hash value, then modulo it by the array length:

    index = hash(key) % capacity\n

    Observing the above formula, when the hash table capacity capacity is fixed, the hash algorithm hash() determines the output value, thereby determining the distribution of key-value pairs in the hash table.

    This means that, to reduce the probability of hash collisions, we should focus on the design of the hash algorithm hash().

    "},{"location":"chapter_hashing/hash_algorithm/#631-goals-of-hash-algorithms","title":"6.3.1 \u00a0 Goals of Hash Algorithms","text":"

    To achieve a \"fast and stable\" hash table data structure, hash algorithms should have the following characteristics:

    • Determinism: For the same input, the hash algorithm should always produce the same output. Only then can the hash table be reliable.
    • High Efficiency: The process of computing the hash value should be fast enough. The smaller the computational overhead, the more practical the hash table.
    • Uniform Distribution: The hash algorithm should ensure that key-value pairs are evenly distributed in the hash table. The more uniform the distribution, the lower the probability of hash collisions.

    In fact, hash algorithms are not only used to implement hash tables but are also widely applied in other fields.

    • Password Storage: To protect the security of user passwords, systems usually do not store the plaintext passwords but rather the hash values of the passwords. When a user enters a password, the system calculates the hash value of the input and compares it with the stored hash value. If they match, the password is considered correct.
    • Data Integrity Check: The data sender can calculate the hash value of the data and send it along; the receiver can recalculate the hash value of the received data and compare it with the received hash value. If they match, the data is considered intact.

    For cryptographic applications, to prevent reverse engineering such as deducing the original password from the hash value, hash algorithms need higher-level security features.

    • Unidirectionality: It should be impossible to deduce any information about the input data from the hash value.
    • Collision Resistance: It should be extremely difficult to find two different inputs that produce the same hash value.
    • Avalanche Effect: Minor changes in the input should lead to significant and unpredictable changes in the output.

    Note that \"Uniform Distribution\" and \"Collision Resistance\" are two separate concepts. Satisfying uniform distribution does not necessarily mean collision resistance. For example, under random input key, the hash function key % 100 can produce a uniformly distributed output. However, this hash algorithm is too simple, and all key with the same last two digits will have the same output, making it easy to deduce a usable key from the hash value, thereby cracking the password.

    "},{"location":"chapter_hashing/hash_algorithm/#632-design-of-hash-algorithms","title":"6.3.2 \u00a0 Design of Hash Algorithms","text":"

    The design of hash algorithms is a complex issue that requires consideration of many factors. However, for some less demanding scenarios, we can also design some simple hash algorithms.

    • Additive Hash: Add up the ASCII codes of each character in the input and use the total sum as the hash value.
    • Multiplicative Hash: Utilize the non-correlation of multiplication, multiplying each round by a constant, accumulating the ASCII codes of each character into the hash value.
    • XOR Hash: Accumulate the hash value by XORing each element of the input data.
    • Rotating Hash: Accumulate the ASCII code of each character into a hash value, performing a rotation operation on the hash value before each accumulation.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig simple_hash.py
    def add_hash(key: str) -> int:\n    \"\"\"\u52a0\u6cd5\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -> int:\n    \"\"\"\u4e58\u6cd5\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -> int:\n    \"\"\"\u5f02\u6216\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -> int:\n    \"\"\"\u65cb\u8f6c\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash << 4) ^ (hash >> 28) ^ ord(c)\n    return hash % modulus\n
    simple_hash.cpp
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n
    simple_hash.java
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n
    simple_hash.cs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n
    simple_hash.go
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash & modulus\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n
    simple_hash.swift
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash & MODULUS\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash << 4) ^ (hash >> 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n
    simple_hash.js
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n
    simple_hash.ts
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n
    simple_hash.dart
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n
    simple_hash.rs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfn add_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfn mul_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfn xor_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash & MODULUS) as i32\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfn rot_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n
    simple_hash.c
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i < strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n
    simple_hash.kt
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfun addHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfun xorHash(key: String): Int {\n    var hash = 0\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n
    simple_hash.rb
    [class]{}-[func]{add_hash}\n\n[class]{}-[func]{mul_hash}\n\n[class]{}-[func]{xor_hash}\n\n[class]{}-[func]{rot_hash}\n
    simple_hash.zig
    [class]{}-[func]{addHash}\n\n[class]{}-[func]{mulHash}\n\n[class]{}-[func]{xorHash}\n\n[class]{}-[func]{rotHash}\n
    Code Visualization

    Full Screen >

    It is observed that the last step of each hash algorithm is to take the modulus of the large prime number \\(1000000007\\) to ensure that the hash value is within an appropriate range. It is worth pondering why emphasis is placed on modulo a prime number, or what are the disadvantages of modulo a composite number? This is an interesting question.

    To conclude: Using a large prime number as the modulus can maximize the uniform distribution of hash values. Since a prime number does not share common factors with other numbers, it can reduce the periodic patterns caused by the modulo operation, thus avoiding hash collisions.

    For example, suppose we choose the composite number \\(9\\) as the modulus, which can be divided by \\(3\\), then all key divisible by \\(3\\) will be mapped to hash values \\(0\\), \\(3\\), \\(6\\).

    \\[ \\begin{aligned} \\text{modulus} & = 9 \\newline \\text{key} & = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\]

    If the input key happens to have this kind of arithmetic sequence distribution, then the hash values will cluster, thereby exacerbating hash collisions. Now, suppose we replace modulus with the prime number \\(13\\), since there are no common factors between key and modulus, the uniformity of the output hash values will be significantly improved.

    \\[ \\begin{aligned} \\text{modulus} & = 13 \\newline \\text{key} & = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\]

    It is worth noting that if the key is guaranteed to be randomly and uniformly distributed, then choosing a prime number or a composite number as the modulus can both produce uniformly distributed hash values. However, when the distribution of key has some periodicity, modulo a composite number is more likely to result in clustering.

    In summary, we usually choose a prime number as the modulus, and this prime number should be large enough to eliminate periodic patterns as much as possible, enhancing the robustness of the hash algorithm.

    "},{"location":"chapter_hashing/hash_algorithm/#633-common-hash-algorithms","title":"6.3.3 \u00a0 Common Hash Algorithms","text":"

    It is not hard to see that the simple hash algorithms mentioned above are quite \"fragile\" and far from reaching the design goals of hash algorithms. For example, since addition and XOR obey the commutative law, additive hash and XOR hash cannot distinguish strings with the same content but in different order, which may exacerbate hash collisions and cause security issues.

    In practice, we usually use some standard hash algorithms, such as MD5, SHA-1, SHA-2, and SHA-3. They can map input data of any length to a fixed-length hash value.

    Over the past century, hash algorithms have been in a continuous process of upgrading and optimization. Some researchers strive to improve the performance of hash algorithms, while others, including hackers, are dedicated to finding security issues in hash algorithms. The Table 6-2 shows hash algorithms commonly used in practical applications.

    • MD5 and SHA-1 have been successfully attacked multiple times and are thus abandoned in various security applications.
    • SHA-2 series, especially SHA-256, is one of the most secure hash algorithms to date, with no successful attacks reported, hence commonly used in various security applications and protocols.
    • SHA-3 has lower implementation costs and higher computational efficiency compared to SHA-2, but its current usage coverage is not as extensive as the SHA-2 series.

    Table 6-2 \u00a0 Common Hash Algorithms

    MD5 SHA-1 SHA-2 SHA-3 Release Year 1992 1995 2002 2008 Output Length 128 bit 160 bit 256/512 bit 224/256/384/512 bit Hash Collisions Frequent Frequent Rare Rare Security Level Low, has been successfully attacked Low, has been successfully attacked High High Applications Abandoned, still used for data integrity checks Abandoned Cryptocurrency transaction verification, digital signatures, etc. Can be used to replace SHA-2"},{"location":"chapter_hashing/hash_algorithm/#hash-values-in-data-structures","title":"Hash Values in Data Structures","text":"

    We know that the keys in a hash table can be of various data types such as integers, decimals, or strings. Programming languages usually provide built-in hash algorithms for these data types to calculate the bucket indices in the hash table. Taking Python as an example, we can use the hash() function to compute the hash values for various data types.

    • The hash values of integers and booleans are their own values.
    • The calculation of hash values for floating-point numbers and strings is more complex, and interested readers are encouraged to study this on their own.
    • The hash value of a tuple is a combination of the hash values of each of its elements, resulting in a single hash value.
    • The hash value of an object is generated based on its memory address. By overriding the hash method of an object, hash values can be generated based on content.

    Tip

    Be aware that the definition and methods of the built-in hash value calculation functions in different programming languages vary.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig built_in_hash.py
    num = 3\nhash_num = hash(num)\n# Hash value of integer 3 is 3\n\nbol = True\nhash_bol = hash(bol)\n# Hash value of boolean True is 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# Hash value of decimal 3.14159 is 326484311674566659\n\nstr = \"Hello \u7b97\u6cd5\"\nhash_str = hash(str)\n# Hash value of string \"Hello \u7b97\u6cd5\" is 4617003410720528961\n\ntup = (12836, \"\u5c0f\u54c8\")\nhash_tup = hash(tup)\n# Hash value of tuple (12836, '\u5c0f\u54c8') is 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# Hash value of ListNode object at 0x1058fd810 is 274267521\n
    built_in_hash.cpp
    int num = 3;\nsize_t hashNum = hash<int>()(num);\n// Hash value of integer 3 is 3\n\nbool bol = true;\nsize_t hashBol = hash<bool>()(bol);\n// Hash value of boolean 1 is 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash<double>()(dec);\n// Hash value of decimal 3.14159 is 4614256650576692846\n\nstring str = \"Hello \u7b97\u6cd5\";\nsize_t hashStr = hash<string>()(str);\n// Hash value of string \"Hello \u7b97\u6cd5\" is 15466937326284535026\n\n// In C++, built-in std::hash() only provides hash values for basic data types\n// Hash values for arrays and objects need to be implemented separately\n
    built_in_hash.java
    int num = 3;\nint hashNum = Integer.hashCode(num);\n// Hash value of integer 3 is 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// Hash value of boolean true is 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// Hash value of decimal 3.14159 is -1340954729\n\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode();\n// Hash value of string \"Hello \u7b97\u6cd5\" is -727081396\n\nObject[] arr = { 12836, \"\u5c0f\u54c8\" };\nint hashTup = Arrays.hashCode(arr);\n// Hash value of array [12836, \u5c0f\u54c8] is 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// Hash value of ListNode object utils.ListNode@7dc5e7b4 is 2110121908\n
    built_in_hash.cs
    int num = 3;\nint hashNum = num.GetHashCode();\n// Hash value of integer 3 is 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// Hash value of boolean true is 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// Hash value of decimal 3.14159 is -1340954729;\n\nstring str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.GetHashCode();\n// Hash value of string \"Hello \u7b97\u6cd5\" is -586107568;\n\nobject[] arr = [12836, \"\u5c0f\u54c8\"];\nint hashTup = arr.GetHashCode();\n// Hash value of array [12836, \u5c0f\u54c8] is 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// Hash value of ListNode object 0 is 39053774;\n
    built_in_hash.go
    // Go does not provide built-in hash code functions\n
    built_in_hash.swift
    let num = 3\nlet hashNum = num.hashValue\n// Hash value of integer 3 is 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// Hash value of boolean true is -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// Hash value of decimal 3.14159 is -2465384235396674631\n\nlet str = \"Hello \u7b97\u6cd5\"\nlet hashStr = str.hashValue\n// Hash value of string \"Hello \u7b97\u6cd5\" is -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"\u5c0f\u54c8\")]\nlet hashTup = arr.hashValue\n// Hash value of array [AnyHashable(12836), AnyHashable(\"\u5c0f\u54c8\")] is -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// Hash value of ListNode object utils.ListNode is -2434780518035996159\n
    built_in_hash.js
    // JavaScript does not provide built-in hash code functions\n
    built_in_hash.ts
    // TypeScript does not provide built-in hash code functions\n
    built_in_hash.dart
    int num = 3;\nint hashNum = num.hashCode;\n// Hash value of integer 3 is 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// Hash value of boolean true is 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// Hash value of decimal 3.14159 is 2570631074981783\n\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode;\n// Hash value of string \"Hello \u7b97\u6cd5\" is 468167534\n\nList arr = [12836, \"\u5c0f\u54c8\"];\nint hashArr = arr.hashCode;\n// Hash value of array [12836, \u5c0f\u54c8] is 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// Hash value of ListNode object Instance of 'ListNode' is 1033450432\n
    built_in_hash.rs
    use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&mut num_hasher);\nlet hash_num = num_hasher.finish();\n// Hash value of integer 3 is 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// Hash value of boolean true is 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// Hash value of decimal 3.14159 is 2566941990314602357\n\nlet str = \"Hello \u7b97\u6cd5\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&mut str_hasher);\nlet hash_str = str_hasher.finish();\n// Hash value of string \"Hello \u7b97\u6cd5\" is 16092673739211250988\n\nlet arr = (&12836, &\"\u5c0f\u54c8\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// Hash value of tuple (12836, \"\u5c0f\u54c8\") is 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&mut hasher);\nlet hash = hasher.finish();\n// Hash value of ListNode object RefCell { value: ListNode { val: 42, next: None } } is 15387811073369036852\n
    built_in_hash.c
    // C does not provide built-in hash code functions\n
    built_in_hash.kt
    \n
    built_in_hash.zig
    \n
    Code Visualization

    Full Screen >

    In many programming languages, only immutable objects can serve as the key in a hash table. If we use a list (dynamic array) as a key, when the contents of the list change, its hash value also changes, and we would no longer be able to find the original value in the hash table.

    Although the member variables of a custom object (such as a linked list node) are mutable, it is hashable. This is because the hash value of an object is usually generated based on its memory address, and even if the contents of the object change, the memory address remains the same, so the hash value remains unchanged.

    You might have noticed that the hash values output in different consoles are different. This is because the Python interpreter adds a random salt to the string hash function each time it starts up. This approach effectively prevents HashDoS attacks and enhances the security of the hash algorithm.

    "},{"location":"chapter_hashing/hash_collision/","title":"6.2 \u00a0 Hash Collision","text":"

    As mentioned in the previous section, usually the input space of a hash function is much larger than its output space, making hash collisions theoretically inevitable. For example, if the input space consists of all integers and the output space is the size of the array capacity, multiple integers will inevitably map to the same bucket index.

    Hash collisions can lead to incorrect query results, severely affecting the usability of hash tables. To solve this problem, we expand the hash table whenever a hash collision occurs, until the collision is resolved. This method is simple and effective but inefficient due to the extensive data transfer and hash value computation involved in resizing the hash table. To improve efficiency, we can adopt the following strategies:

    1. Improve the data structure of the hash table, allowing it to function normally in the event of a hash collision.
    2. Only perform resizing when necessary, i.e., when hash collisions are severe.

    There are mainly two methods for improving the structure of hash tables: \"Separate Chaining\" and \"Open Addressing\".

    "},{"location":"chapter_hashing/hash_collision/#621-separate-chaining","title":"6.2.1 \u00a0 Separate Chaining","text":"

    In the original hash table, each bucket can store only one key-value pair. \"Separate chaining\" transforms individual elements into a linked list, with key-value pairs as list nodes, storing all colliding key-value pairs in the same list. The Figure 6-5 shows an example of a hash table with separate chaining.

    Figure 6-5 \u00a0 Separate Chaining Hash Table

    The operations of a hash table implemented with separate chaining have changed as follows:

    • Querying Elements: Input key, pass through the hash function to obtain the bucket index, access the head node of the list, then traverse the list and compare key to find the target key-value pair.
    • Adding Elements: First access the list head node via the hash function, then add the node (key-value pair) to the list.
    • Deleting Elements: Access the list head based on the hash function's result, then traverse the list to find and remove the target node.

    Separate chaining has the following limitations:

    • Increased Space Usage: The linked list contains node pointers, which consume more memory space than arrays.
    • Reduced Query Efficiency: Due to the need for linear traversal of the list to find the corresponding element.

    The code below provides a simple implementation of a separate chaining hash table, with two things to note:

    • Lists (dynamic arrays) are used instead of linked lists for simplicity. In this setup, the hash table (array) contains multiple buckets, each of which is a list.
    • This implementation includes a method for resizing the hash table. When the load factor exceeds \\(\\frac{2}{3}\\), we resize the hash table to twice its original size.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map_chaining.py
    class HashMapChaining:\n    \"\"\"\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\n        self.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\n        self.load_thres = 2.0 / 3.0  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        self.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\n        self.buckets = [[] for _ in range(self.capacity)]  # \u6876\u6570\u7ec4\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -> float:\n        \"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -> str | None:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        return None\n\n    def 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\n        if self.load_factor() > self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n        # \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        buckets = self.buckets\n        # \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -> \" + pair.val)\n            print(res)\n
    hash_map_chaining.cpp
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n  private:\n    int size;                       // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;                   // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres;               // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;                // \u6269\u5bb9\u500d\u6570\n    vector<vector<Pair *>> buckets; // \u6876\u6570\u7ec4\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~HashMapChaining() {\n        for (auto &bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // \u91ca\u653e\u5185\u5b58\n                delete pair;\n            }\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        int index = hashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (Pair *pair : buckets[index]) {\n            if (pair->key == key) {\n                return pair->val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n        return \"\";\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (Pair *pair : buckets[index]) {\n            if (pair->key == key) {\n                pair->val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &bucket = buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (int i = 0; i < bucket.size(); i++) {\n            if (bucket[i]->key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n                delete tmp;                       // \u91ca\u653e\u5185\u5b58\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        vector<vector<Pair *>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (auto &bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair->key, pair->val);\n                // \u91ca\u653e\u5185\u5b58\n                delete pair;\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (auto &bucket : buckets) {\n            cout << \"[\";\n            for (Pair *pair : bucket) {\n                cout << pair->key << \" -> \" << pair->val << \", \";\n            }\n            cout << \"]\\n\";\n        }\n    }\n};\n
    hash_map_chaining.java
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio; // \u6269\u5bb9\u500d\u6570\n    List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList<>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.add(new ArrayList<>());\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    String get(int key) {\n        int index = hashFunc(key);\n        List<Pair> bucket = buckets.get(index);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, String val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List<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\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List<Pair> bucket = buckets.get(index);\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        List<List<Pair>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new ArrayList<>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.add(new ArrayList<>());\n        }\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (List<Pair> bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (List<Pair> bucket : buckets) {\n            List<String> res = new ArrayList<>();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -> \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n
    hash_map_chaining.cs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio; // \u6269\u5bb9\u500d\u6570\n    List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List<List<Pair>>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (LoadFactor() > loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void Extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        List<List<Pair>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new List<List<Pair>>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        foreach (List<Pair> bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (List<Pair> bucket in buckets) {\n            List<string> res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -> \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n
    hash_map_chaining.go
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntype hashMapChaining struct {\n    size        int      // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity    int      // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    loadThres   float64  // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extendRatio int      // \u6269\u5bb9\u500d\u6570\n    buckets     [][]pair // \u6876\u6570\u7ec4\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i < 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n    return \"\"\n}\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\n    if m.loadFactor() > m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // \u5207\u7247\u5220\u9664\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i < len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i < m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -> \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n
    hash_map_chaining.swift
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    var loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    var extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: [[Pair]] // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    func hashFunc(key: Int) -> Int {\n        key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    func loadFactor() -> Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de nil\n        return nil\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if loadFactor() > loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    func extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -> \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n
    hash_map_chaining.js
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    #size; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio; // \u6269\u5bb9\u500d\u6570\n    #buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key, val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (let i = 0; i < bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -> ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n
    hash_map_chaining.ts
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    #size: number; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity: number; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres: number; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio: number; // \u6269\u5bb9\u500d\u6570\n    #buckets: Pair[][]; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key: number, val: string): void {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (let i = 0; i < bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend(): void {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -> ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n
    hash_map_chaining.dart
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n  late int size; // \u952e\u503c\u5bf9\u6570\u91cf\n  late int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n  late double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n  late int extendRatio; // \u6269\u5bb9\u500d\u6570\n  late List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) => []);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* \u8d1f\u8f7d\u56e0\u5b50 */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List<Pair> bucket = buckets[index];\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n    return null;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor() > loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List<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\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List<Pair> bucket = buckets[index];\n    // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n  void extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    List<List<Pair>> bucketsTmp = buckets;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) => []);\n    size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (List<Pair> bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (List<Pair> bucket in buckets) {\n      List<String> res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -> ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n
    hash_map_chaining.rs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nstruct HashMapChaining {\n    size: i32,\n    capacity: i32,\n    load_thres: f32,\n    extend_ratio: i32,\n    buckets: Vec<Vec<Pair>>,\n}\n\nimpl HashMapChaining {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new() -> Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        key as usize % self.capacity as usize\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fn load_factor(&self) -> f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fn remove(&mut self, key: i32) -> Option<String> {\n        let index = self.hash_func(key);\n        let bucket = &mut self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for i in 0..bucket.len() {\n            if bucket[i].key == key {\n                let pair = bucket.remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        None\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fn extend(&mut self) {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let buckets_tmp = std::mem::replace(&mut self.buckets, vec![]);\n\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fn print(&self) {\n        for bucket in &self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -> {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fn put(&mut self, key: i32, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if self.load_factor() > self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n        let bucket = &mut self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val.clone();\n                return;\n            }\n        }\n        let bucket = &mut self.buckets[index];\n\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        let pair = Pair {\n            key,\n            val: val.clone(),\n        };\n        bucket.push(pair);\n        self.size += 1;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fn get(&self, key: i32) -> Option<&str> {\n        let index = self.hash_func(key);\n        let bucket = &self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket {\n            if pair.key == key {\n                return Some(&pair.val);\n            }\n        }\n\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        None\n    }\n}\n
    hash_map_chaining.c
    /* \u94fe\u8868\u8282\u70b9 */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntypedef struct {\n    int size;         // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;  // \u6269\u5bb9\u500d\u6570\n    Node **buckets;   // \u6876\u6570\u7ec4\n} HashMapChaining;\n\n/* \u6784\u9020\u51fd\u6570 */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap->size = 0;\n    hashMap->capacity = 4;\n    hashMap->loadThres = 2.0 / 3.0;\n    hashMap->extendRatio = 2;\n    hashMap->buckets = (Node **)malloc(hashMap->capacity * sizeof(Node *));\n    for (int i = 0; i < hashMap->capacity; i++) {\n        hashMap->buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Node *cur = hashMap->buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur->next;\n            free(tmp->pair);\n            free(tmp);\n        }\n    }\n    free(hashMap->buckets);\n    free(hashMap);\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap->capacity;\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap->size / (double)hashMap->capacity;\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    Node *cur = hashMap->buckets[index];\n    while (cur) {\n        if (cur->pair->key == key) {\n            return cur->pair->val;\n        }\n        cur = cur->next;\n    }\n    return \"\"; // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor(hashMap) > hashMap->loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n    Node *cur = hashMap->buckets[index];\n    while (cur) {\n        if (cur->pair->key == key) {\n            strcpy(cur->pair->val, val); // \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n            return;\n        }\n        cur = cur->next;\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair->key = key;\n    strcpy(newPair->val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode->pair = newPair;\n    newNode->next = hashMap->buckets[index];\n    hashMap->buckets[index] = newNode;\n    hashMap->size++;\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend(HashMapChaining *hashMap) {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    int oldCapacity = hashMap->capacity;\n    Node **oldBuckets = hashMap->buckets;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    hashMap->capacity *= hashMap->extendRatio;\n    hashMap->buckets = (Node **)malloc(hashMap->capacity * sizeof(Node *));\n    for (int i = 0; i < hashMap->capacity; i++) {\n        hashMap->buckets[i] = NULL;\n    }\n    hashMap->size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (int i = 0; i < oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur->pair->key, cur->pair->val);\n            Node *temp = cur;\n            cur = cur->next;\n            // \u91ca\u653e\u5185\u5b58\n            free(temp->pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap->buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur->pair->key == key) {\n            // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n            if (pre) {\n                pre->next = cur->next;\n            } else {\n                hashMap->buckets[index] = cur->next;\n            }\n            // \u91ca\u653e\u5185\u5b58\n            free(cur->pair);\n            free(cur);\n            hashMap->size--;\n            return;\n        }\n        pre = cur;\n        cur = cur->next;\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Node *cur = hashMap->buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -> %s, \", cur->pair->key, cur->pair->val);\n            cur = cur->next;\n        }\n        printf(\"]\\n\");\n    }\n}\n
    hash_map_chaining.kt
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining() {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    val loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    val extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: MutableList<MutableList<Pair>> // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = ArrayList(capacity)\n        for (i in 0..<capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (pair in bucket) {\n            if (pair.key == key) return pair.value\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair.value = value\n                return\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        val pair = Pair(key, value)\n        bucket.add(pair)\n        size++\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fun extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        val bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        // mutablelist \u65e0\u56fa\u5b9a\u5927\u5c0f\n        buckets = mutableListOf()\n        for (i in 0..<capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair.value)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf<String>()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair.value\n                res.add(\"$k -> $v\")\n            }\n            println(res)\n        }\n    }\n}\n
    hash_map_chaining.rb
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.zig
    [class]{HashMapChaining}-[func]{}\n
    Code Visualization

    Full Screen >

    It's worth noting that when the list is very long, the query efficiency \\(O(n)\\) is poor. At this point, the list can be converted to an \"AVL tree\" or \"Red-Black tree\" to optimize the time complexity of the query operation to \\(O(\\log n)\\).

    "},{"location":"chapter_hashing/hash_collision/#622-open-addressing","title":"6.2.2 \u00a0 Open Addressing","text":"

    \"Open addressing\" does not introduce additional data structures but uses \"multiple probes\" to handle hash collisions. The probing methods mainly include linear probing, quadratic probing, and double hashing.

    Let's use linear probing as an example to introduce the mechanism of open addressing hash tables.

    "},{"location":"chapter_hashing/hash_collision/#1-linear-probing","title":"1. \u00a0 Linear Probing","text":"

    Linear probing uses a fixed-step linear search for probing, differing from ordinary hash tables.

    • Inserting Elements: Calculate the bucket index using the hash function. If the bucket already contains an element, linearly traverse forward from the conflict position (usually with a step size of \\(1\\)) until an empty bucket is found, then insert the element.
    • Searching for Elements: If a hash collision is found, use the same step size to linearly traverse forward until the corresponding element is found and return value; if an empty bucket is encountered, it means the target element is not in the hash table, so return None.

    The Figure 6-6 shows the distribution of key-value pairs in an open addressing (linear probing) hash table. According to this hash function, keys with the same last two digits will be mapped to the same bucket. Through linear probing, they are stored consecutively in that bucket and the buckets below it.

    Figure 6-6 \u00a0 Distribution of Key-Value Pairs in Open Addressing (Linear Probing) Hash Table

    However, linear probing tends to create \"clustering\". Specifically, the longer a continuous position in the array is occupied, the more likely these positions are to encounter hash collisions, further promoting the growth of these clusters and eventually leading to deterioration in the efficiency of operations.

    It's important to note that we cannot directly delete elements in an open addressing hash table. Deleting an element creates an empty bucket None in the array. When searching for elements, if linear probing encounters this empty bucket, it will return, making the elements below this bucket inaccessible. The program may incorrectly assume these elements do not exist, as shown in the Figure 6-7 .

    Figure 6-7 \u00a0 Query Issues Caused by Deletion in Open Addressing

    To solve this problem, we can use a \"lazy deletion\" mechanism: instead of directly removing elements from the hash table, use a constant TOMBSTONE to mark the bucket. In this mechanism, both None and TOMBSTONE represent empty buckets and can hold key-value pairs. However, when linear probing encounters TOMBSTONE, it should continue traversing since there may still be key-value pairs below it.

    However, lazy deletion may accelerate the degradation of hash table performance. Every deletion operation produces a delete mark, and as TOMBSTONE increases, so does the search time, as linear probing may have to skip multiple TOMBSTONE to find the target element.

    Therefore, consider recording the index of the first TOMBSTONE encountered during linear probing and swapping the target element found with this TOMBSTONE. The advantage of this is that each time a query or addition is performed, the element is moved to a bucket closer to the ideal position (starting point of probing), thereby optimizing the query efficiency.

    The code below implements an open addressing (linear probing) hash table with lazy deletion. To make fuller use of the hash table space, we treat the hash table as a \"circular array,\" continuing to traverse from the beginning when the end of the array is passed.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map_open_addressing.py
    class HashMapOpenAddressing:\n    \"\"\"\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\n        self.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\n        self.load_thres = 2.0 / 3.0  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        self.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\n        self.buckets: list[Pair | None] = [None] * self.capacity  # \u6876\u6570\u7ec4\n        self.TOMBSTONE = Pair(-1, \"-1\")  # \u5220\u9664\u6807\u8bb0\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -> float:\n        \"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -> int:\n        \"\"\"\u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while self.buckets[index] is not None:\n            # \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if self.buckets[index].key == key:\n                # \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                return index  # \u8fd4\u56de\u6876\u7d22\u5f15\n            # \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % self.capacity\n        # \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -> str:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de None\n        return None\n\n    def 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\n        if self.load_factor() > self.load_thres:\n            self.extend()\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n        # \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        buckets_tmp = self.buckets\n        # \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"->\", pair.val)\n
    hash_map_open_addressing.cpp
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity = 4;                     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    const double loadThres = 2.0 / 3.0;     // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    const int extendRatio = 2;            // \u6269\u5bb9\u500d\u6570\n    vector<Pair *> buckets;               // \u6876\u6570\u7ec4\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr && pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != nullptr) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index]->key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            return buckets[index]->val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n        return \"\";\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            buckets[index]->val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        vector<Pair *> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = vector<Pair *>(capacity, nullptr);\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr && pair != TOMBSTONE) {\n                put(pair->key, pair->val);\n                delete pair;\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout << \"nullptr\" << endl;\n            } else if (pair == TOMBSTONE) {\n                cout << \"TOMBSTONE\" << endl;\n            } else {\n                cout << pair->key << \" -> \" << pair->val << endl;\n            }\n        }\n    }\n};\n
    hash_map_open_addressing.java
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    private int capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private final double loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private final int extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n    private Pair[] buckets; // \u6876\u6570\u7ec4\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index].key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public String get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void put(int key, String val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    private void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        Pair[] bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (Pair pair : bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -> \" + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.cs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n    Pair[] buckets; // \u6876\u6570\u7ec4\n    Pair TOMBSTONE = new(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index].key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (LoadFactor() > loadThres) {\n            Extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void Extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        Pair[] bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -> \" + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.go
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\ntype hashMapOpenAddressing struct {\n    size        int     // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity    int     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    loadThres   float64 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extendRatio int     // \u6269\u5bb9\u500d\u6570\n    buckets     []*pair // \u6876\u6570\u7ec4\n    TOMBSTONE   *pair   // \u5220\u9664\u6807\u8bb0\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &pair{-1, \"-1\"},\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // \u6839\u636e\u952e\u8ba1\u7b97\u54c8\u5e0c\u503c\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // \u8ba1\u7b97\u5f53\u524d\u8d1f\u8f7d\u56e0\u5b50\n}\n\n/* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // \u83b7\u53d6\u521d\u59cb\u7d22\u5f15\n    firstTombstone := -1     // \u8bb0\u5f55\u9047\u5230\u7684\u7b2c\u4e00\u4e2aTOMBSTONE\u7684\u4f4d\u7f6e\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n            }\n            return index // \u8fd4\u56de\u627e\u5230\u7684\u7d22\u5f15\n        }\n        if firstTombstone == -1 && h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\u7684\u4f4d\u7f6e\n        }\n        index = (index + 1) % h.capacity // \u7ebf\u6027\u63a2\u6d4b\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    }\n    return \"\" // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de \"\"\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() > h.loadThres {\n        h.extend() // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    }\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &pair{key, val} // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        h.size++\n    } else {\n        h.buckets[index].val = val // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val\n    }\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        h.size--\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    h.capacity *= h.extendRatio           // \u66f4\u65b0\u5bb9\u91cf\n    h.buckets = make([]*pair, h.capacity) // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    h.size = 0                            // \u91cd\u7f6e\u5927\u5c0f\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for _, pair := range oldBuckets {\n        if pair != nil && pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -> %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n
    hash_map_open_addressing.swift
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    var loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    var extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: [Pair?] // \u6876\u6570\u7ec4\n    var TOMBSTONE: Pair // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    func hashFunc(key: Int) -> Int {\n        key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    func loadFactor() -> Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    func findBucket(key: Int) -> Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while buckets[index] != nil {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if buckets[index]!.key == key {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if firstTombstone == -1 && buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return nil\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if loadFactor() > loadThres {\n            extend()\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    func extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -> \\(pair!.val)\")\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.js
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    #size; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio; // \u6269\u5bb9\u500d\u6570\n    #buckets; // \u6876\u6570\u7ec4\n    #TOMBSTONE; // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0; // \u952e\u503c\u5bf9\u6570\u91cf\n        this.#capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n        this.#loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        this.#extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n        this.#buckets = Array(this.#capacity).fill(null); // \u6876\u6570\u7ec4\n        this.#TOMBSTONE = new Pair(-1, '-1'); // \u5220\u9664\u6807\u8bb0\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (this.#buckets[index] !== null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (this.#buckets[index].key === key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (\n                firstTombstone === -1 &&\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % this.#capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key, val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const pair of bucketsTmp) {\n            if (pair !== null && pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -> ' + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.ts
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private size: number; // \u952e\u503c\u5bf9\u6570\u91cf\n    private capacity: number; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private loadThres: number; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private extendRatio: number; // \u6269\u5bb9\u500d\u6570\n    private buckets: Array<Pair | null>; // \u6876\u6570\u7ec4\n    private TOMBSTONE: Pair; // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.size = 0; // \u952e\u503c\u5bf9\u6570\u91cf\n        this.capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n        this.loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        this.extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n        this.buckets = Array(this.capacity).fill(null); // \u6876\u6570\u7ec4\n        this.TOMBSTONE = new Pair(-1, '-1'); // \u5220\u9664\u6807\u8bb0\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (this.buckets[index] !== null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (this.buckets[index]!.key === key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (\n                firstTombstone === -1 &&\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % this.capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key: number): string | null {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key: number, val: string): void {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.loadFactor() > this.loadThres) {\n            this.extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key: number): void {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    private extend(): void {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const pair of bucketsTmp) {\n            if (pair !== null && pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -> ' + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.dart
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n  late int _size; // \u952e\u503c\u5bf9\u6570\u91cf\n  int _capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n  double _loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n  int _extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n  late List<Pair?> _buckets; // \u6876\u6570\u7ec4\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) => null);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* \u8d1f\u8f7d\u56e0\u5b50 */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n    while (_buckets[index] != null) {\n      // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n      if (_buckets[index]!.key == key) {\n        // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n        }\n        return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n      }\n      // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n      if (firstTombstone == -1 && _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n      index = (index + 1) % _capacity;\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n    return null;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor() > _loadThres) {\n      extend();\n    }\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n  void extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    List<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\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null && pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -> ${pair.val}\");\n      }\n    }\n  }\n}\n
    hash_map_open_addressing.rs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nstruct HashMapOpenAddressing {\n    size: usize,                // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity: usize,            // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    load_thres: f64,            // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extend_ratio: usize,        // \u6269\u5bb9\u500d\u6570\n    buckets: Vec<Option<Pair>>, // \u6876\u6570\u7ec4\n    TOMBSTONE: Option<Pair>,    // \u5220\u9664\u6807\u8bb0\n}\n\nimpl HashMapOpenAddressing {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new() -> Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fn load_factor(&self) -> f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    fn find_bucket(&mut self, key: i32) -> usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while self.buckets[index].is_some() {\n            // \u82e5\u9047\u5230 key\uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u5efa\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if first_tombstone == -1 && self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % self.capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fn get(&mut self, key: i32) -> Option<&str> {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &pair.val as &str);\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        None\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fn put(&mut self, key: i32, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if self.load_factor() > self.load_thres {\n            self.extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fn remove(&mut self, key: i32) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fn extend(&mut self) {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let buckets_tmp = self.buckets.clone();\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fn print(&self) {\n        for pair in &self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -> {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.c
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\ntypedef struct {\n    int size;         // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;  // \u6269\u5bb9\u500d\u6570\n    Pair **buckets;   // \u6876\u6570\u7ec4\n    Pair *TOMBSTONE;  // \u5220\u9664\u6807\u8bb0\n} HashMapOpenAddressing;\n\n/* \u6784\u9020\u51fd\u6570 */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap->size = 0;\n    hashMap->capacity = 4;\n    hashMap->loadThres = 2.0 / 3.0;\n    hashMap->extendRatio = 2;\n    hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);\n    hashMap->TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap->TOMBSTONE->key = -1;\n    hashMap->TOMBSTONE->val = \"-1\";\n\n    return hashMap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Pair *pair = hashMap->buckets[i];\n        if (pair != NULL && pair != hashMap->TOMBSTONE) {\n            free(pair->val);\n            free(pair);\n        }\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap->capacity;\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap->size / (double)hashMap->capacity;\n}\n\n/* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n    while (hashMap->buckets[index] != NULL) {\n        // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        if (hashMap->buckets[index]->key == key) {\n            // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n            if (firstTombstone != -1) {\n                hashMap->buckets[firstTombstone] = hashMap->buckets[index];\n                hashMap->buckets[index] = hashMap->TOMBSTONE;\n                return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n            }\n            return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n        }\n        // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n        if (firstTombstone == -1 && hashMap->buckets[index] == hashMap->TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n        index = (index + 1) % hashMap->capacity;\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        return hashMap->buckets[index]->val;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n    return \"\";\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor(hashMap) > hashMap->loadThres) {\n        extend(hashMap);\n    }\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        free(hashMap->buckets[index]->val);\n        hashMap->buckets[index]->val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap->buckets[index]->val, val);\n        hashMap->buckets[index]->val[strlen(val)] = '\\0';\n        return;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair->key = key;\n    pair->val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair->val, val);\n    pair->val[strlen(val)] = '\\0';\n\n    hashMap->buckets[index] = pair;\n    hashMap->size++;\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        Pair *pair = hashMap->buckets[index];\n        free(pair->val);\n        free(pair);\n        hashMap->buckets[index] = hashMap->TOMBSTONE;\n        hashMap->size--;\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    Pair **bucketsTmp = hashMap->buckets;\n    int oldCapacity = hashMap->capacity;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    hashMap->capacity *= hashMap->extendRatio;\n    hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);\n    hashMap->size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (int i = 0; i < oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL && pair != hashMap->TOMBSTONE) {\n            put(hashMap, pair->key, pair->val);\n            free(pair->val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Pair *pair = hashMap->buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap->TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -> %s\\n\", pair->key, pair->val);\n        }\n    }\n}\n
    hash_map_open_addressing.kt
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private var size: Int = 0 // \u952e\u503c\u5bf9\u6570\u91cf\n    private var capacity = 4 // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private val loadThres: Double = 2.0 / 3.0 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private val extendRatio = 2 // \u6269\u5bb9\u500d\u6570\n    private var buckets: Array<Pair?> // \u6876\u6570\u7ec4\n    private val TOMBSTONE = Pair(-1, \"-1\") // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init {\n        buckets = arrayOfNulls(capacity)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index]?.key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index]?.value\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend()\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index]!!.value = value\n            return\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = Pair(key, value)\n        size++\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fun extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        val bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (pair in bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                put(pair.key, pair.value)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -> ${pair.value}\")\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.rb
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.zig
    [class]{HashMapOpenAddressing}-[func]{}\n
    "},{"location":"chapter_hashing/hash_collision/#2-quadratic-probing","title":"2. \u00a0 Quadratic Probing","text":"

    Quadratic probing is similar to linear probing and is one of the common strategies of open addressing. When a collision occurs, quadratic probing does not simply skip a fixed number of steps but skips \"the square of the number of probes,\" i.e., \\(1, 4, 9, \\dots\\) steps.

    Quadratic probing has the following advantages:

    • Quadratic probing attempts to alleviate the clustering effect of linear probing by skipping the distance of the square of the number of probes.
    • Quadratic probing skips larger distances to find empty positions, helping to distribute data more evenly.

    However, quadratic probing is not perfect:

    • Clustering still exists, i.e., some positions are more likely to be occupied than others.
    • Due to the growth of squares, quadratic probing may not probe the entire hash table, meaning it might not access empty buckets even if they exist in the hash table.
    "},{"location":"chapter_hashing/hash_collision/#3-double-hashing","title":"3. \u00a0 Double Hashing","text":"

    As the name suggests, the double hashing method uses multiple hash functions \\(f_1(x)\\), \\(f_2(x)\\), \\(f_3(x)\\), \\(\\dots\\) for probing.

    • Inserting Elements: If hash function \\(f_1(x)\\) encounters a conflict, try \\(f_2(x)\\), and so on, until an empty position is found and the element is inserted.
    • Searching for Elements: Search in the same order of hash functions until the target element is found and returned; if an empty position is encountered or all hash functions have been tried, it indicates the element is not in the hash table, then return None.

    Compared to linear probing, double hashing is less prone to clustering but involves additional computation for multiple hash functions.

    Tip

    Please note that open addressing (linear probing, quadratic probing, and double hashing) hash tables all have the issue of \"not being able to directly delete elements.\"

    "},{"location":"chapter_hashing/hash_collision/#623-choice-of-programming-languages","title":"6.2.3 \u00a0 Choice of Programming Languages","text":"

    Various programming languages have adopted different hash table implementation strategies, here are a few examples:

    • Python uses open addressing. The dict dictionary uses pseudo-random numbers for probing.
    • Java uses separate chaining. Since JDK 1.8, when the array length in HashMap reaches 64 and the length of a linked list reaches 8, the linked list is converted to a red-black tree to improve search performance.
    • Go uses separate chaining. Go stipulates that each bucket can store up to 8 key-value pairs, and if the capacity is exceeded, an overflow bucket is connected; when there are too many overflow buckets, a special equal-size expansion operation is performed to ensure performance.
    "},{"location":"chapter_hashing/hash_map/","title":"6.1 \u00a0 Hash Table","text":"

    A \"hash table\", also known as a \"hash map\", achieves efficient element querying by establishing a mapping between keys and values. Specifically, when we input a key into the hash table, we can retrieve the corresponding value in \\(O(1)\\) time.

    As shown in the Figure 6-1 , given \\(n\\) students, each with two pieces of data: \"name\" and \"student number\". If we want to implement a query feature that returns the corresponding name when given a student number, we can use the hash table shown in the Figure 6-1 .

    Figure 6-1 \u00a0 Abstract representation of a hash table

    Apart from hash tables, arrays and linked lists can also be used to implement querying functions. Their efficiency is compared in the Table 6-1 .

    • Adding Elements: Simply add the element to the end of the array (or linked list), using \\(O(1)\\) time.
    • Querying Elements: Since the array (or linked list) is unordered, it requires traversing all the elements, using \\(O(n)\\) time.
    • Deleting Elements: First, locate the element, then delete it from the array (or linked list), using \\(O(n)\\) time.

    Table 6-1 \u00a0 Comparison of Element Query Efficiency

    Array Linked List Hash Table Find Element \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) Add Element \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Delete Element \\(O(n)\\) \\(O(n)\\) \\(O(1)\\)

    Observations reveal that the time complexity for adding, deleting, and querying in a hash table is \\(O(1)\\), which is highly efficient.

    "},{"location":"chapter_hashing/hash_map/#611-common-operations-of-hash-table","title":"6.1.1 \u00a0 Common Operations of Hash Table","text":"

    Common operations of a hash table include initialization, querying, adding key-value pairs, and deleting key-value pairs, etc. Example code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig hash_map.py
    # Initialize hash table\nhmap: dict = {}\n\n# Add operation\n# Add key-value pair (key, value) to the hash table\nhmap[12836] = \"Xiao Ha\"\nhmap[15937] = \"Xiao Luo\"\nhmap[16750] = \"Xiao Suan\"\nhmap[13276] = \"Xiao Fa\"\nhmap[10583] = \"Xiao Ya\"\n\n# Query operation\n# Input key into hash table, get value\nname: str = hmap[15937]\n\n# Delete operation\n# Delete key-value pair (key, value) from hash table\nhmap.pop(10583)\n
    hash_map.cpp
    /* Initialize hash table */\nunordered_map<int, string> map;\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap[12836] = \"Xiao Ha\";\nmap[15937] = \"Xiao Luo\";\nmap[16750] = \"Xiao Suan\";\nmap[13276] = \"Xiao Fa\";\nmap[10583] = \"Xiao Ya\";\n\n/* Query operation */\n// Input key into hash table, get value\nstring name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.erase(10583);\n
    hash_map.java
    /* Initialize hash table */\nMap<Integer, String> map = new HashMap<>();\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap.put(12836, \"Xiao Ha\");   \nmap.put(15937, \"Xiao Luo\");   \nmap.put(16750, \"Xiao Suan\");   \nmap.put(13276, \"Xiao Fa\");\nmap.put(10583, \"Xiao Ya\");\n\n/* Query operation */\n// Input key into hash table, get value\nString name = map.get(15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583);\n
    hash_map.cs
    /* Initialize hash table */\nDictionary<int, string> map = new() {\n    /* Add operation */\n    // Add key-value pair (key, value) to the hash table\n    { 12836, \"Xiao Ha\" },\n    { 15937, \"Xiao Luo\" },\n    { 16750, \"Xiao Suan\" },\n    { 13276, \"Xiao Fa\" },\n    { 10583, \"Xiao Ya\" }\n};\n\n/* Query operation */\n// Input key into hash table, get value\nstring name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.Remove(10583);\n
    hash_map_test.go
    /* Initialize hash table */\nhmap := make(map[int]string)\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nhmap[12836] = \"Xiao Ha\"\nhmap[15937] = \"Xiao Luo\"\nhmap[16750] = \"Xiao Suan\"\nhmap[13276] = \"Xiao Fa\"\nhmap[10583] = \"Xiao Ya\"\n\n/* Query operation */\n// Input key into hash table, get value\nname := hmap[15937]\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\ndelete(hmap, 10583)\n
    hash_map.swift
    /* Initialize hash table */\nvar map: [Int: String] = [:]\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap[12836] = \"Xiao Ha\"\nmap[15937] = \"Xiao Luo\"\nmap[16750] = \"Xiao Suan\"\nmap[13276] = \"Xiao Fa\"\nmap[10583] = \"Xiao Ya\"\n\n/* Query operation */\n// Input key into hash table, get value\nlet name = map[15937]!\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.removeValue(forKey: 10583)\n
    hash_map.js
    /* Initialize hash table */\nconst map = new Map();\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap.set(12836, 'Xiao Ha');\nmap.set(15937, 'Xiao Luo');\nmap.set(16750, 'Xiao Suan');\nmap.set(13276, 'Xiao Fa');\nmap.set(10583, 'Xiao Ya');\n\n/* Query operation */\n// Input key into hash table, get value\nlet name = map.get(15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.delete(10583);\n
    hash_map.ts
    /* Initialize hash table */\nconst map = new Map<number, string>();\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap.set(12836, 'Xiao Ha');\nmap.set(15937, 'Xiao Luo');\nmap.set(16750, 'Xiao Suan');\nmap.set(13276, 'Xiao Fa');\nmap.set(10583, 'Xiao Ya');\nconsole.info('\\nAfter adding, the hash table is\\nKey -> Value');\nconsole.info(map);\n\n/* Query operation */\n// Input key into hash table, get value\nlet name = map.get(15937);\nconsole.info('\\nInput student number 15937, query name ' + name);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.delete(10583);\nconsole.info('\\nAfter deleting 10583, the hash table is\\nKey -> Value');\nconsole.info(map);\n
    hash_map.dart
    /* Initialize hash table */\nMap<int, String> map = {};\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap[12836] = \"Xiao Ha\";\nmap[15937] = \"Xiao Luo\";\nmap[16750] = \"Xiao Suan\";\nmap[13276] = \"Xiao Fa\";\nmap[10583] = \"Xiao Ya\";\n\n/* Query operation */\n// Input key into hash table, get value\nString name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583);\n
    hash_map.rs
    use std::collections::HashMap;\n\n/* Initialize hash table */\nlet mut map: HashMap<i32, String> = HashMap::new();\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap.insert(12836, \"Xiao Ha\".to_string());\nmap.insert(15937, \"Xiao Luo\".to_string());\nmap.insert(16750, \"Xiao Suan\".to_string());\nmap.insert(13279, \"Xiao Fa\".to_string());\nmap.insert(10583, \"Xiao Ya\".to_string());\n\n/* Query operation */\n// Input key into hash table, get value\nlet _name: Option<&String> = map.get(&15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nlet _removed_value: Option<String> = map.remove(&10583);\n
    hash_map.c
    // C does not provide a built-in hash table\n
    hash_map.kt
    \n
    hash_map.zig
    \n
    Code Visualization

    Full Screen >

    There are three common ways to traverse a hash table: traversing key-value pairs, keys, and values. Example code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig hash_map.py
    # Traverse hash table\n# Traverse key-value pairs key->value\nfor key, value in hmap.items():\n    print(key, \"->\", value)\n# Traverse keys only\nfor key in hmap.keys():\n    print(key)\n# Traverse values only\nfor value in hmap.values():\n    print(value)\n
    hash_map.cpp
    /* Traverse hash table */\n// Traverse key-value pairs key->value\nfor (auto kv: map) {\n    cout << kv.first << \" -> \" << kv.second << endl;\n}\n// Traverse using iterator key->value\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout << iter->first << \"->\" << iter->second << endl;\n}\n
    hash_map.java
    /* Traverse hash table */\n// Traverse key-value pairs key->value\nfor (Map.Entry<Integer, String> kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -> \" + kv.getValue());\n}\n// Traverse keys only\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// Traverse values only\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n
    hash_map.cs
    /* Traverse hash table */\n// Traverse key-value pairs Key->Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -> \" + kv.Value);\n}\n// Traverse keys only\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// Traverse values only\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n
    hash_map_test.go
    /* Traverse hash table */\n// Traverse key-value pairs key->value\nfor key, value := range hmap {\n    fmt.Println(key, \"->\", value)\n}\n// Traverse keys only\nfor key := range hmap {\n    fmt.Println(key)\n}\n// Traverse values only\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n
    hash_map.swift
    /* Traverse hash table */\n// Traverse key-value pairs Key->Value\nfor (key, value) in map {\n    print(\"\\(key) -> \\(value)\")\n}\n// Traverse keys only\nfor key in map.keys {\n    print(key)\n}\n// Traverse values only\nfor value in map.values {\n    print(value)\n}\n
    hash_map.js
    /* Traverse hash table */\nconsole.info('\\nTraverse key-value pairs Key->Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -> ' + v);\n}\nconsole.info('\\nTraverse keys only Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nTraverse values only Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n
    hash_map.ts
    /* Traverse hash table */\nconsole.info('\\nTraverse key-value pairs Key->Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -> ' + v);\n}\nconsole.info('\\nTraverse keys only Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nTraverse values only Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n
    hash_map.dart
    /* Traverse hash table */\n// Traverse key-value pairs Key->Value\nmap.forEach((key, value) {\nprint('$key -> $value');\n});\n\n// Traverse keys only Key\nmap.keys.forEach((key) {\nprint(key);\n});\n\n// Traverse values only Value\nmap.values.forEach((value) {\nprint(value);\n});\n
    hash_map.rs
    /* Traverse hash table */\n// Traverse key-value pairs Key->Value\nfor (key, value) in &map {\n    println!(\"{key} -> {value}\");\n}\n\n// Traverse keys only Key\nfor key in map.keys() {\n    println!(\"{key}\"); \n}\n\n// Traverse values only Value\nfor value in map.values() {\n    println!(\"{value}\");\n}\n
    hash_map.c
    // C does not provide a built-in hash table\n
    hash_map.kt
    \n
    hash_map.zig
    // Zig example is not provided\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_hashing/hash_map/#612-simple-implementation-of-hash-table","title":"6.1.2 \u00a0 Simple Implementation of Hash Table","text":"

    First, let's consider the simplest case: implementing a hash table using just an array. In the hash table, each empty slot in the array is called a \"bucket\", and each bucket can store one key-value pair. Therefore, the query operation involves finding the bucket corresponding to the key and retrieving the value from it.

    So, how do we locate the appropriate bucket based on the key? This is achieved through a \"hash function\". The role of the hash function is to map a larger input space to a smaller output space. In a hash table, the input space is all possible keys, and the output space is all buckets (array indices). In other words, input a key, and we can use the hash function to determine the storage location of the corresponding key-value pair in the array.

    The calculation process of the hash function for a given key is divided into the following two steps:

    1. Calculate the hash value using a certain hash algorithm hash().
    2. Take the modulus of the hash value with the number of buckets (array length) capacity to obtain the array index index.
    index = hash(key) % capacity\n

    Afterward, we can use index to access the corresponding bucket in the hash table and thereby retrieve the value.

    Assuming array length capacity = 100 and hash algorithm hash(key) = key, the hash function is key % 100. The Figure 6-2 uses key as the student number and value as the name to demonstrate the working principle of the hash function.

    Figure 6-2 \u00a0 Working principle of hash function

    The following code implements a simple hash table. Here, we encapsulate key and value into a class Pair to represent the key-value pair.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_hash_map.py
    class Pair:\n    \"\"\"\u952e\u503c\u5bf9\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        # \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -> str:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        index: int = self.hash_func(key)\n        # \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\n        self.buckets[index] = None\n\n    def entry_set(self) -> list[Pair]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -> list[int]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u952e\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -> list[str]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u503c\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"->\", pair.val)\n
    array_hash_map.cpp
    /* \u952e\u503c\u5bf9 */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this->key = key;\n        this->val = val;\n    }\n};\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n  private:\n    vector<Pair *> buckets;\n\n  public:\n    ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = vector<Pair *>(100);\n    }\n\n    ~ArrayHashMap() {\n        // \u91ca\u653e\u5185\u5b58\n        for (const auto &bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair->val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // \u91ca\u653e\u5185\u5b58\u5e76\u7f6e\u4e3a nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    vector<Pair *> pairSet() {\n        vector<Pair *> pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    vector<int> keySet() {\n        vector<int> keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair->key);\n            }\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    vector<string> valueSet() {\n        vector<string> valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair->val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout << kv->key << \" -> \" << kv->val << endl;\n        }\n    }\n};\n
    array_hash_map.java
    /* \u952e\u503c\u5bf9 */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private List<Pair> buckets;\n\n    public ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = new ArrayList<>();\n        for (int i = 0; i < 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets.set(index, null);\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public List<Pair> pairSet() {\n        List<Pair> pairSet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public List<Integer> keySet() {\n        List<Integer> keySet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public List<String> valueSet() {\n        List<String> valueSet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -> \" + kv.val);\n        }\n    }\n}\n
    array_hash_map.cs
    /* \u952e\u503c\u5bf9 int->string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    List<Pair?> buckets;\n    public ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = [];\n        for (int i = 0; i < 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public List<Pair> PairSet() {\n        List<Pair> pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public List<int> KeySet() {\n        List<int> keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public List<string> ValueSet() {\n        List<string> valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -> \" + kv.val);\n        }\n    }\n}\n
    array_hash_map.go
    /* \u952e\u503c\u5bf9 */\ntype pair struct {\n    key int\n    val string\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nfunc newArrayHashMap() *arrayHashMap {\n    // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n    buckets := make([]*pair, 100)\n    return &arrayHashMap{buckets: buckets}\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\n    a.buckets[index] = nil\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e\u5bf9 */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* \u83b7\u53d6\u6240\u6709\u503c */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"->\", pair.val)\n        }\n    }\n}\n
    array_hash_map.swift
    /* \u952e\u503c\u5bf9 */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -> Bool {\n        lhs.key == rhs.key && lhs.val == rhs.val\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private func hashFunc(key: Int) -> Int {\n        let index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = nil\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    func pairSet() -> [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    func keySet() -> [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    func valueSet() -> [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -> \\(pair.val)\")\n        }\n    }\n}\n
    array_hash_map.js
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        this.#buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    entries() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    keys() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    values() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -> ${pair.val}`);\n        }\n    }\n}\n
    array_hash_map.ts
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        this.buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -> ${pair.val}`);\n        }\n    }\n}\n
    array_hash_map.dart
    /* \u952e\u503c\u5bf9 */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n  late List<Pair?> _buckets;\n\n  ArrayHashMap() {\n    // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n    _buckets = List.filled(100, null);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n  List<Pair> pairSet() {\n    List<Pair> pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u952e */\n  List<int> keySet() {\n    List<int> keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u503c */\n  List<String> values() {\n    List<String> valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -> ${kv.val}\");\n    }\n  }\n}\n
    array_hash_map.rs
    /* \u952e\u503c\u5bf9 */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\npub struct ArrayHashMap {\n    buckets: Vec<Option<Pair>>,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -> ArrayHashMap {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        key as usize % 100\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    pub fn get(&self, key: i32) -> Option<&String> {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &pair.val)\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    pub fn put(&mut self, key: i32, val: &str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    pub fn remove(&mut self, key: i32) {\n        let index = self.hash_func(key);\n        // \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\n        self.buckets[index] = None;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    pub fn entry_set(&self) -> Vec<&Pair> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    pub fn key_set(&self) -> Vec<&i32> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &pair.key))\n            .collect()\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    pub fn value_set(&self) -> Vec<&String> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &pair.val))\n            .collect()\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    pub fn print(&self) {\n        for pair in self.entry_set() {\n            println!(\"{} -> {}\", pair.key, pair.val);\n        }\n    }\n}\n
    array_hash_map.c
    /* \u952e\u503c\u5bf9 int->string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntypedef struct {\n    Pair *buckets[HASHTABLE_CAPACITY];\n} ArrayHashMap;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    return hmap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            free(hmap->buckets[i]->val);\n            free(hmap->buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair->key = key;\n    Pair->val = malloc(strlen(val) + 1);\n    strcpy(Pair->val, val);\n\n    int index = hashFunc(key);\n    hmap->buckets[index] = Pair;\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap->buckets[index]->val);\n    free(hmap->buckets[index]);\n    hmap->buckets[index] = NULL;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            entries[index].key = hmap->buckets[i]->key;\n            entries[index].val = malloc(strlen(hmap->buckets[i]->val) + 1);\n            strcpy(entries[index].val, hmap->buckets[i]->val);\n            index++;\n        }\n    }\n    set->set = entries;\n    set->len = total;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            keys[index] = hmap->buckets[i]->key;\n            index++;\n        }\n    }\n    set->set = keys;\n    set->len = total;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u503c */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            vals[index] = hmap->buckets[i]->val;\n            index++;\n        }\n    }\n    set->set = vals;\n    set->len = total;\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i < set.len; i++) {\n        printf(\"%d -> %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n
    array_hash_map.kt
    /* \u952e\u503c\u5bf9 */\nclass Pair(\n    var key: Int,\n    var value: String\n)\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private val buckets = arrayOfNulls<Pair>(100)\n\n    init {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        for (i in 0..<100) {\n            buckets[i] = null\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair.value\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        val pair = Pair(key, value)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    fun pairSet(): MutableList<Pair> {\n        val pairSet = ArrayList<Pair>()\n        for (pair in buckets) {\n            if (pair != null) pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    fun keySet(): MutableList<Int> {\n        val keySet = ArrayList<Int>()\n        for (pair in buckets) {\n            if (pair != null) keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    fun valueSet(): MutableList<String> {\n        val valueSet = ArrayList<String>()\n        for (pair in buckets) {\n            pair?.let { valueSet.add(it.value) }\n        }\n        return valueSet\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val value = kv.value\n            println(\"${key}->${value}\")\n        }\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private val buckets = arrayOfNulls<Pair>(100)\n\n    init {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        for (i in 0..<100) {\n            buckets[i] = null\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair.value\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        val pair = Pair(key, value)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    fun pairSet(): MutableList<Pair> {\n        val pairSet = ArrayList<Pair>()\n        for (pair in buckets) {\n            if (pair != null) pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    fun keySet(): MutableList<Int> {\n        val keySet = ArrayList<Int>()\n        for (pair in buckets) {\n            if (pair != null) keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    fun valueSet(): MutableList<String> {\n        val valueSet = ArrayList<String>()\n        for (pair in buckets) {\n            pair?.let { valueSet.add(it.value) }\n        }\n        return valueSet\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val value = kv.value\n            println(\"${key}->${value}\")\n        }\n    }\n}\n
    array_hash_map.rb
    [class]{Pair}-[func]{}\n\n[class]{ArrayHashMap}-[func]{}\n
    array_hash_map.zig
    // \u952e\u503c\u5bf9\nconst Pair = struct {\n    key: usize = undefined,\n    val: []const u8 = undefined,\n\n   pub fn init(key: usize, val: []const u8) Pair {\n        return Pair {\n            .key = key,\n            .val = val,\n        };\n    }\n};\n\n// \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\nfn ArrayHashMap(comptime T: type) type {\n    return struct {\n        bucket: ?std.ArrayList(?T) = null,\n        mem_allocator: std.mem.Allocator = undefined,\n\n        const Self = @This();\n\n        // \u6784\u9020\u51fd\u6570\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            self.mem_allocator = allocator;\n            // \u521d\u59cb\u5316\u4e00\u4e2a\u957f\u5ea6\u4e3a 100 \u7684\u6876\uff08\u6570\u7ec4\uff09\n            self.bucket = std.ArrayList(?T).init(self.mem_allocator);\n            var i: i32 = 0;\n            while (i < 100) : (i += 1) {\n                try self.bucket.?.append(null);\n            }\n        }\n\n        // \u6790\u6784\u51fd\u6570\n        pub fn deinit(self: *Self) void {\n            if (self.bucket != null) self.bucket.?.deinit();\n        }\n\n        // \u54c8\u5e0c\u51fd\u6570\n        fn hashFunc(key: usize) usize {\n            var index = key % 100;\n            return index;\n        }\n\n        // \u67e5\u8be2\u64cd\u4f5c\n        pub fn get(self: *Self, key: usize) []const u8 {\n            var index = hashFunc(key);\n            var pair = self.bucket.?.items[index];\n            return pair.?.val;\n        }\n\n        // \u6dfb\u52a0\u64cd\u4f5c\n        pub fn put(self: *Self, key: usize, val: []const u8) !void {\n            var pair = Pair.init(key, val);\n            var index = hashFunc(key);\n            self.bucket.?.items[index] = pair;\n        }\n\n        // \u5220\u9664\u64cd\u4f5c\n        pub fn remove(self: *Self, key: usize) !void {\n            var index = hashFunc(key);\n            // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n            self.bucket.?.items[index] = null;\n        }       \n\n        // \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\n        pub fn pairSet(self: *Self) !std.ArrayList(T) {\n            var entry_set = std.ArrayList(T).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try entry_set.append(item.?);\n            }\n            return entry_set;\n        }  \n\n        // \u83b7\u53d6\u6240\u6709\u952e\n        pub fn keySet(self: *Self) !std.ArrayList(usize) {\n            var key_set = std.ArrayList(usize).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try key_set.append(item.?.key);\n            }\n            return key_set;\n        }  \n\n        // \u83b7\u53d6\u6240\u6709\u503c\n        pub fn valueSet(self: *Self) !std.ArrayList([]const u8) {\n            var value_set = std.ArrayList([]const u8).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try value_set.append(item.?.val);\n            }\n            return value_set;\n        }\n\n        // \u6253\u5370\u54c8\u5e0c\u8868\n        pub fn print(self: *Self) !void {\n            var entry_set = try self.pairSet();\n            defer entry_set.deinit();\n            for (entry_set.items) |item| {\n                std.debug.print(\"{} -> {s}\\n\", .{item.key, item.val});\n            }\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_hashing/hash_map/#613-hash-collision-and-resizing","title":"6.1.3 \u00a0 Hash Collision and Resizing","text":"

    Fundamentally, the role of the hash function is to map the entire input space of all keys to the output space of all array indices. However, the input space is often much larger than the output space. Therefore, theoretically, there must be situations where \"multiple inputs correspond to the same output\".

    For the hash function in the above example, if the last two digits of the input key are the same, the output of the hash function will also be the same. For example, when querying for students with student numbers 12836 and 20336, we find:

    12836 % 100 = 36\n20336 % 100 = 36\n

    As shown in the Figure 6-3 , both student numbers point to the same name, which is obviously incorrect. This situation where multiple inputs correspond to the same output is known as \"hash collision\".

    Figure 6-3 \u00a0 Example of hash collision

    It is easy to understand that the larger the capacity \\(n\\) of the hash table, the lower the probability of multiple keys being allocated to the same bucket, and the fewer the collisions. Therefore, expanding the capacity of the hash table can reduce hash collisions.

    As shown in the Figure 6-4 , before expansion, key-value pairs (136, A) and (236, D) collided; after expansion, the collision is resolved.

    Figure 6-4 \u00a0 Hash table expansion

    Similar to array expansion, resizing a hash table requires migrating all key-value pairs from the original hash table to the new one, which is time-consuming. Furthermore, since the capacity capacity of the hash table changes, we need to recalculate the storage positions of all key-value pairs using the hash function, which adds to the computational overhead of the resizing process. Therefore, programming languages often reserve a sufficiently large capacity for the hash table to prevent frequent resizing.

    The \"load factor\" is an important concept for hash tables. It is defined as the ratio of the number of elements in the hash table to the number of buckets. It is used to measure the severity of hash collisions and is often used as a trigger for resizing the hash table. For example, in Java, when the load factor exceeds \\(0.75\\), the system will resize the hash table to twice its original size.

    "},{"location":"chapter_hashing/summary/","title":"6.4 \u00a0 Summary","text":""},{"location":"chapter_hashing/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"
    • Given an input key, a hash table can retrieve the corresponding value in \\(O(1)\\) time, which is highly efficient.
    • Common hash table operations include querying, adding key-value pairs, deleting key-value pairs, and traversing the hash table.
    • The hash function maps a key to an array index, allowing access to the corresponding bucket to retrieve the value.
    • Two different keys may end up with the same array index after hashing, leading to erroneous query results. This phenomenon is known as hash collision.
    • The larger the capacity of the hash table, the lower the probability of hash collisions. Therefore, hash table resizing can mitigate hash collisions. Similar to array resizing, hash table resizing is costly.
    • Load factor, defined as the ratio of the number of elements to the number of buckets in the hash table, reflects the severity of hash collisions and is often used as a trigger for resizing the hash table.
    • Chaining addresses hash collisions by converting each element into a linked list, storing all colliding elements in the same list. However, excessively long lists can reduce query efficiency, which can be improved by converting the lists into red-black trees.
    • Open addressing handles hash collisions through multiple probes. Linear probing uses a fixed step size but cannot delete elements and is prone to clustering. Multiple hashing uses several hash functions for probing, making it less susceptible to clustering but increasing computational load.
    • Different programming languages adopt various hash table implementations. For example, Java's HashMap uses chaining, while Python's dict employs open addressing.
    • In hash tables, we desire hash algorithms with determinism, high efficiency, and uniform distribution. In cryptography, hash algorithms should also possess collision resistance and the avalanche effect.
    • Hash algorithms typically use large prime numbers as moduli to ensure uniform distribution of hash values and reduce hash collisions.
    • Common hash algorithms include MD5, SHA-1, SHA-2, and SHA-3. MD5 is often used for file integrity checks, while SHA-2 is commonly used in secure applications and protocols.
    • Programming languages usually provide built-in hash algorithms for data types to calculate bucket indices in hash tables. Generally, only immutable objects are hashable.
    "},{"location":"chapter_hashing/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: When does the time complexity of a hash table degrade to \\(O(n)\\)?

    The time complexity of a hash table can degrade to \\(O(n)\\) when hash collisions are severe. When the hash function is well-designed, the capacity is set appropriately, and collisions are evenly distributed, the time complexity is \\(O(1)\\). We usually consider the time complexity to be \\(O(1)\\) when using built-in hash tables in programming languages.

    Q: Why not use the hash function \\(f(x) = x\\)? This would eliminate collisions.

    Under the hash function \\(f(x) = x\\), each element corresponds to a unique bucket index, which is equivalent to an array. However, the input space is usually much larger than the output space (array length), so the last step of a hash function is often to take the modulo of the array length. In other words, the goal of a hash table is to map a larger state space to a smaller one while providing \\(O(1)\\) query efficiency.

    Q: Why can hash tables be more efficient than arrays, linked lists, or binary trees, even though they are implemented using these structures?

    Firstly, hash tables have higher time efficiency but lower space efficiency. A significant portion of memory in hash tables remains unused.

    Secondly, they are only more efficient in specific use cases. If a feature can be implemented with the same time complexity using an array or a linked list, it's usually faster than using a hash table. This is because the computation of the hash function incurs overhead, making the constant factor in the time complexity larger.

    Lastly, the time complexity of hash tables can degrade. For example, in chaining, we perform search operations in a linked list or red-black tree, which still risks degrading to \\(O(n)\\) time.

    Q: Does multiple hashing also have the flaw of not being able to delete elements directly? Can space marked as deleted be reused?

    Multiple hashing is a form of open addressing, and all open addressing methods have the drawback of not being able to delete elements directly; they require marking elements as deleted. Marked spaces can be reused. When inserting new elements into the hash table, and the hash function points to a position marked as deleted, that position can be used by the new element. This maintains the probing sequence of the hash table while ensuring efficient use of space.

    Q: Why do hash collisions occur during the search process in linear probing?

    During the search process, the hash function points to the corresponding bucket and key-value pair. If the key doesn't match, it indicates a hash collision. Therefore, linear probing will search downwards at a predetermined step size until the correct key-value pair is found or the search fails.

    Q: Why can resizing a hash table alleviate hash collisions?

    The last step of a hash function often involves taking the modulo of the array length \\(n\\), to keep the output within the array index range. When resizing, the array length \\(n\\) changes, and the indices corresponding to the keys may also change. Keys that were previously mapped to the same bucket might be distributed across multiple buckets after resizing, thereby mitigating hash collisions.

    "},{"location":"chapter_introduction/","title":"Chapter 1. \u00a0 Introduction to Algorithms","text":"

    Abstract

    A graceful maiden dances, intertwined with the data, her skirt swaying to the melody of algorithms.

    She invites you to a dance, follow her steps, and enter the world of algorithms full of logic and beauty.

    "},{"location":"chapter_introduction/#chapter-contents","title":"Chapter Contents","text":"
    • 1.1 \u00a0 Algorithms are Everywhere
    • 1.2 \u00a0 What is an Algorithm
    • 1.3 \u00a0 Summary
    "},{"location":"chapter_introduction/algorithms_are_everywhere/","title":"1.1 \u00a0 Algorithms are Everywhere","text":"

    When we hear the word \"algorithm,\" we naturally think of mathematics. However, many algorithms do not involve complex mathematics but rely more on basic logic, which can be seen everywhere in our daily lives.

    Before formally discussing algorithms, there's an interesting fact worth sharing: you have already unconsciously learned many algorithms and have become accustomed to applying them in your daily life. Here, I will give a few specific examples to prove this point.

    Example 1: Looking Up a Dictionary. In an English dictionary, words are listed alphabetically. Suppose we're searching for a word that starts with the letter \\(r\\). This is typically done in the following way:

    1. Open the dictionary to about halfway and check the first letter on the page, let's say the letter is \\(m\\).
    2. Since \\(r\\) comes after \\(m\\) in the alphabet, we can ignore the first half of the dictionary and focus on the latter half.
    3. Repeat steps 1. and 2. until you find the page where the word starts with \\(r\\).
    <1><2><3><4><5>

    Figure 1-1 \u00a0 Process of Looking Up a Dictionary

    This essential skill for elementary students, looking up a dictionary, is actually the famous \"Binary Search\" algorithm. From a data structure perspective, we can consider the dictionary as a sorted \"array\"; from an algorithmic perspective, the series of actions taken to look up a word in the dictionary can be viewed as \"Binary Search.\"

    Example 2: Organizing Playing Cards. When playing cards, we need to arrange the cards in our hand in ascending order, as shown in the following process.

    1. Divide the playing cards into \"ordered\" and \"unordered\" sections, assuming initially the leftmost card is already in order.
    2. Take out a card from the unordered section and insert it into the correct position in the ordered section; after this, the leftmost two cards are in order.
    3. Continue to repeat step 2. until all cards are in order.

    Figure 1-2 \u00a0 Playing Cards Sorting Process

    The above method of organizing playing cards is essentially the \"Insertion Sort\" algorithm, which is very efficient for small datasets. Many programming languages' sorting functions include the insertion sort.

    Example 3: Making Change. Suppose we buy goods worth \\(69\\) yuan at a supermarket and give the cashier \\(100\\) yuan, then the cashier needs to give us \\(31\\) yuan in change. They would naturally complete the thought process as shown below.

    1. The options are currencies smaller than \\(31\\), including \\(1\\), \\(5\\), \\(10\\), and \\(20\\).
    2. Take out the largest \\(20\\) from the options, leaving \\(31 - 20 = 11\\).
    3. Take out the largest \\(10\\) from the remaining options, leaving \\(11 - 10 = 1\\).
    4. Take out the largest \\(1\\) from the remaining options, leaving \\(1 - 1 = 0\\).
    5. Complete the change-making, with the solution being \\(20 + 10 + 1 = 31\\).

    Figure 1-3 \u00a0 Change making process

    In the above steps, we make the best choice at each step (using the largest denomination possible), ultimately resulting in a feasible change-making plan. From the perspective of data structures and algorithms, this method is essentially a \"Greedy\" algorithm.

    From cooking a meal to interstellar travel, almost all problem-solving involves algorithms. The advent of computers allows us to store data structures in memory and write code to call the CPU and GPU to execute algorithms. In this way, we can transfer real-life problems to computers, solving various complex issues more efficiently.

    Tip

    If concepts such as data structures, algorithms, arrays, and binary search still seem somewhat obsecure, I encourage you to continue reading. This book will gently guide you into the realm of understanding data structures and algorithms.

    "},{"location":"chapter_introduction/summary/","title":"1.3 \u00a0 Summary","text":"
    • Algorithms are ubiquitous in daily life and are not as inaccessible and complex as they might seem. In fact, we have already unconsciously learned many algorithms to solve various problems in life.
    • The principle of looking up a word in a dictionary is consistent with the binary search algorithm. The binary search algorithm embodies the important algorithmic concept of divide and conquer.
    • The process of organizing playing cards is very similar to the insertion sort algorithm. The insertion sort algorithm is suitable for sorting small datasets.
    • The steps of making change in currency essentially follow the greedy algorithm, where each step involves making the best possible choice at the moment.
    • An algorithm is a set of instructions or steps used to solve a specific problem within a finite amount of time, while a data structure is the way data is organized and stored in a computer.
    • Data structures and algorithms are closely linked. Data structures are the foundation of algorithms, and algorithms are the stage to utilize the functions of data structures.
    • We can liken data structures and algorithms to building blocks. The blocks represent data, the shape and connection method of the blocks represent data structures, and the steps of assembling the blocks correspond to algorithms.
    "},{"location":"chapter_introduction/what_is_dsa/","title":"1.2 \u00a0 What is an Algorithm","text":""},{"location":"chapter_introduction/what_is_dsa/#121-definition-of-an-algorithm","title":"1.2.1 \u00a0 Definition of an Algorithm","text":"

    An \"algorithm\" is a set of instructions or steps to solve a specific problem within a finite amount of time. It has the following characteristics:

    • The problem is clearly defined, including unambiguous definitions of input and output.
    • The algorithm is feasible, meaning it can be completed within a finite number of steps, time, and memory space.
    • Each step has a definitive meaning. The output is consistently the same under the same inputs and conditions.
    "},{"location":"chapter_introduction/what_is_dsa/#122-definition-of-a-data-structure","title":"1.2.2 \u00a0 Definition of a Data Structure","text":"

    A \"data structure\" is a way of organizing and storing data in a computer, with the following design goals:

    • Minimize space occupancy to save computer memory.
    • Make data operations as fast as possible, covering data access, addition, deletion, updating, etc.
    • Provide concise data representation and logical information to enable efficient algorithm execution.

    Designing data structures is a balancing act, often requiring trade-offs. If you want to improve in one aspect, you often need to compromise in another. Here are two examples:

    • Compared to arrays, linked lists offer more convenience in data addition and deletion but sacrifice data access speed.
    • Graphs, compared to linked lists, provide richer logical information but require more memory space.
    "},{"location":"chapter_introduction/what_is_dsa/#123-relationship-between-data-structures-and-algorithms","title":"1.2.3 \u00a0 Relationship Between Data Structures and Algorithms","text":"

    As shown in the Figure 1-4 , data structures and algorithms are highly related and closely integrated, specifically in the following three aspects:

    • Data structures are the foundation of algorithms. They provide structured data storage and methods for manipulating data for algorithms.
    • Algorithms are the stage where data structures come into play. The data structure alone only stores data information; it is through the application of algorithms that specific problems can be solved.
    • Algorithms can often be implemented based on different data structures, but their execution efficiency can vary greatly. Choosing the right data structure is key.

    Figure 1-4 \u00a0 Relationship between data structures and algorithms

    Data structures and algorithms can be likened to a set of building blocks, as illustrated in the Figure 1-5 . A building block set includes numerous pieces, accompanied by detailed assembly instructions. Following these instructions step by step allows us to construct an intricate block model.

    Figure 1-5 \u00a0 Assembling blocks

    The detailed correspondence between the two is shown in the Table 1-1 .

    Table 1-1 \u00a0 Comparing Data Structures and Algorithms to Building Blocks

    Data Structures and Algorithms Building Blocks Input data Unassembled blocks Data structure Organization of blocks, including shape, size, connections, etc Algorithm A series of steps to assemble the blocks into the desired shape Output data Completed Block model

    It's worth noting that data structures and algorithms are independent of programming languages. For this reason, this book is able to provide implementations in multiple programming languages.

    Conventional Abbreviation

    In real-life discussions, we often refer to \"Data Structures and Algorithms\" simply as \"Algorithms\". For example, the well-known LeetCode algorithm problems actually test both data structure and algorithm knowledge.

    "},{"location":"chapter_preface/","title":"Chapter 0. \u00a0 Preface","text":"

    Abstract

    Algorithms are like a beautiful symphony, with each line of code flowing like a rhythm.

    May this book ring softly in your mind, leaving a unique and profound melody.

    "},{"location":"chapter_preface/#chapter-contents","title":"Chapter Contents","text":"
    • 0.1 \u00a0 About This Book
    • 0.2 \u00a0 How to Read
    • 0.3 \u00a0 Summary
    "},{"location":"chapter_preface/about_the_book/","title":"0.1 \u00a0 About This Book","text":"

    This open-source project aims to create a free, and beginner-friendly crash course on data structures and algorithms.

    • Using animated illustrations, it delivers structured insights into data structures and algorithmic concepts, ensuring comprehensibility and a smooth learning curve.
    • Run code with just one click, supporting Java, C++, Python, Go, JS, TS, C#, Swift, Rust, Dart, Zig and other languages.
    • Readers are encouraged to engage with each other in the discussion area for each section, questions and comments are usually answered within two days.
    "},{"location":"chapter_preface/about_the_book/#011-target-audience","title":"0.1.1 \u00a0 Target Audience","text":"

    If you are new to algorithms with limited exposure, or you have accumulated some experience in algorithms, but you only have a vague understanding of data structures and algorithms, and you are constantly jumping between \"yep\" and \"hmm\", then this book is for you!

    If you have already accumulated a certain amount of problem-solving experience, and are familiar with most types of problems, then this book can help you review and organize your algorithm knowledge system. The repository's source code can be used as a \"problem-solving toolkit\" or an \"algorithm cheat sheet\".

    If you are an algorithm expert, we look forward to receiving your valuable suggestions, or join us and collaborate.

    Prerequisites

    You should know how to write and read simple code in at least one programming language.

    "},{"location":"chapter_preface/about_the_book/#012-content-structure","title":"0.1.2 \u00a0 Content Structure","text":"

    The main content of the book is shown in the following figure.

    • Complexity Analysis: explores aspects and methods for evaluating data structures and algorithms. Covers methods of deriving time complexity and space complexity, along with common types and examples.
    • Data Structures: focuses on fundamental data types, classification methods, definitions, pros and cons, common operations, types, applications, and implementation methods of data structures such as array, linked list, stack, queue, hash table, tree, heap, graph, etc.
    • Algorithms: defines algorithms, discusses their pros and cons, efficiency, application scenarios, problem-solving steps, and includes sample questions for various algorithms such as search, sorting, divide and conquer, backtracking, dynamic programming, greedy algorithms, and more.

    Figure 0-1 \u00a0 Main Content of the Book

    "},{"location":"chapter_preface/about_the_book/#013-acknowledgements","title":"0.1.3 \u00a0 Acknowledgements","text":"

    This book is continuously improved with the joint efforts of many contributors from the open-source community. Thanks to each writer who invested their time and energy, listed in the order generated by GitHub: krahets, codingonion, nuomi1, Gonglja, Reanon, justin-tse, danielsss, hpstory, S-N-O-R-L-A-X, night-cruise, msk397, gvenusleo, RiverTwilight, gyt95, zhuoqinyue, Zuoxun, Xia-Sang, mingXta, FangYuan33, GN-Yu, IsChristina, xBLACKICEx, guowei-gong, Cathay-Chen, mgisr, JoseHung, qualifier1024, pengchzn, Guanngxu, longsizhuo, L-Super, what-is-me, yuan0221, lhxsm, Slone123c, WSL0809, longranger2, theNefelibatas, xiongsp, JeffersonHuang, hongyun-robot, K3v123, yuelinxin, a16su, gaofer, malone6, Wonderdch, xjr7670, DullSword, Horbin-Magician, NI-SW, reeswell, XC-Zero, XiaChuerwu, yd-j, iron-irax, huawuque404, MolDuM, Nigh, KorsChen, foursevenlove, 52coder, bubble9um, youshaoXG, curly210102, gltianwen, fanchenggang, Transmigration-zhou, FloranceYeh, FreddieLi, ShiMaRing, lipusheng, Javesun99, JackYang-hellobobo, shanghai-Jerry, 0130w, Keynman, psychelzh, logan-qiu, ZnYang2018, MwumLi, 1ch0, Phoenix0415, qingpeng9802, Richard-Zhang1019, QiLOL, Suremotoo, Turing-1024-Lee, Evilrabbit520, GaochaoZhu, ZJKung, linzeyan, hezhizhen, ZongYangL, beintentional, czruby, coderlef, dshlstarr, szu17dmy, fbigm, gledfish, hts0000, boloboloda, iStig, jiaxianhua, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, liuxjerry, lucaswangdev, lyl625760, chadyi, noobcodemaker, selear, siqyka, syd168, 4yDX3906, tao363, wangwang105, weibk, yabo083, yi427, yishangzhang, zhouLion, baagod, ElaBosak233, xb534, luluxia, yanedie, thomasq0, YangXuanyi and th1nk3r-ing.

    The code review work for this book was completed by codingonion, Gonglja, gvenusleo, hpstory, justin\u2010tse, krahets, night-cruise, nuomi1, and Reanon (listed in alphabetical order). Thanks to them for their time and effort, ensuring the standardization and uniformity of the code in various languages.

    Throughout the creation of this book, numerous individuals provided invaluable assistance, including but not limited to:

    • Thanks to my mentor at the company, Dr. Xi Li, who encouraged me in a conversation to \"get moving fast,\" which solidified my determination to write this book;
    • Thanks to my girlfriend Bubble, as the first reader of this book, for offering many valuable suggestions from the perspective of a beginner in algorithms, making this book more suitable for newbies;
    • Thanks to Tengbao, Qibao, and Feibao for coming up with a creative name for this book, evoking everyone's fond memories of writing their first line of code \"Hello World!\";
    • Thanks to Xiaoquan for providing professional help in intellectual property, which has played a significant role in the development of this open-source book;
    • Thanks to Sutong for designing a beautiful cover and logo for this book, and for patiently making multiple revisions under my insistence;
    • Thanks to @squidfunk for providing writing and typesetting suggestions, as well as his developed open-source documentation theme Material-for-MkDocs.

    Throughout the writing journey, I delved into numerous textbooks and articles on data structures and algorithms. These works served as exemplary models, ensuring the accuracy and quality of this book's content. I extend my gratitude to all who preceded me for their invaluable contributions!

    This book advocates a combination of hands-on and minds-on learning, inspired in this regard by \"Dive into Deep Learning\". I highly recommend this excellent book to all readers.

    Heartfelt thanks to my parents, whose ongoing support and encouragement have allowed me to do this interesting work.

    "},{"location":"chapter_preface/suggestions/","title":"0.2 \u00a0 How to Read","text":"

    Tip

    For the best reading experience, it is recommended that you read through this section.

    "},{"location":"chapter_preface/suggestions/#021-writing-conventions","title":"0.2.1 \u00a0 Writing Conventions","text":"
    • Chapters marked with '*' after the title are optional and contain relatively challenging content. If you are short on time, it is advisable to skip them.
    • Key technical terms and their English equivalents are enclosed in Bold + italics brackets, for example, array. It's advisable to familiarize yourself with these for better comprehension of technical texts.
    • Proprietary terms and words with specific meanings are indicated with \u201cquotation marks\u201d to avoid ambiguity.
    • Bolded text indicates key content or summary statements, which deserve special attention.
    • When it comes to terms that are inconsistent between programming languages, this book follows Python, for example using \\(\\text{None}\\) to mean \"null\".
    • This book partially ignores the comment conventions for programming languages in exchange for a more compact layout of the content. The comments primarily consist of three types: title comments, content comments, and multi-line comments.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    \"\"\"Header comments for labeling functions, classes, test samples, etc\"\"\"\"\n\n# Comments for explaining details\n\n\"\"\"\nMultiline\ncomments\n\"\"\"\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    // Header comments for labeling functions, classes, test samples, etc\n\n// Comments for explaining details.\n\n// Multiline\n// comments\n
    "},{"location":"chapter_preface/suggestions/#022-efficient-learning-via-animated-illustrations","title":"0.2.2 \u00a0 Efficient Learning via Animated Illustrations","text":"

    Compared with text, videos and pictures have a higher density of information and are more structured, making them easier to understand. In this book, key and difficult concepts are mainly presented through animations and illustrations, with text serving as explanations and supplements.

    When encountering content with animations or illustrations as shown in the Figure 0-2 , prioritize understanding the figure, with text as supplementary, integrating both for a comprehensive understanding.

    Figure 0-2 \u00a0 Animated Illustration Example

    "},{"location":"chapter_preface/suggestions/#023-deepen-understanding-through-coding-practice","title":"0.2.3 \u00a0 Deepen Understanding through Coding Practice","text":"

    The source code of this book is hosted on the GitHub Repository. As shown in the Figure 0-3 , the source code comes with test examples and can be executed with just a single click.

    If time permits, it's recommended to type out the code yourself. If pressed for time, at least read and run all the codes.

    Compared to just reading code, writing code often yields more learning. Learning by doing is the real way to learn.

    Figure 0-3 \u00a0 Running Code Example

    Setting up to run the code involves three main steps.

    Step 1: Install a local programming environment. Follow the tutorial in the appendix for installation, or skip this step if already installed.

    Step 2: Clone or download the code repository. Visit the GitHub Repository.

    If Git is installed, use the following command to clone the repository:

    git clone https://github.com/krahets/hello-algo.git\n

    Alternatively, you can also click the \"Download ZIP\" button at the location shown in the Figure 0-4 to directly download the code as a compressed ZIP file. Then, you can simply extract it locally.

    Figure 0-4 \u00a0 Cloning Repository and Downloading Code

    Step 3: Run the source code. As shown in the Figure 0-5 , for the code block labeled with the file name at the top, we can find the corresponding source code file in the codes folder of the repository. These files can be executed with a single click, which will help you save unnecessary debugging time and allow you to focus on learning.

    Figure 0-5 \u00a0 Code Block and Corresponding Source Code File

    "},{"location":"chapter_preface/suggestions/#024-learning-together-in-discussion","title":"0.2.4 \u00a0 Learning Together in Discussion","text":"

    While reading this book, please don't skip over the points that you didn't learn. Feel free to post your questions in the comment section. We will be happy to answer them and can usually respond within two days.

    As illustrated in the Figure 0-6 , each chapter features a comment section at the bottom. I encourage you to pay attention to these comments. They not only expose you to others' encountered problems, aiding in identifying knowledge gaps and sparking deeper contemplation, but also invite you to generously contribute by answering fellow readers' inquiries, sharing insights, and fostering mutual improvement.

    Figure 0-6 \u00a0 Comment Section Example

    "},{"location":"chapter_preface/suggestions/#025-algorithm-learning-path","title":"0.2.5 \u00a0 Algorithm Learning Path","text":"

    Overall, the journey of mastering data structures and algorithms can be divided into three stages:

    1. Stage 1: Introduction to algorithms. We need to familiarize ourselves with the characteristics and usage of various data structures and learn about the principles, processes, uses, and efficiency of different algorithms.
    2. Stage 2: Practicing algorithm problems. It is recommended to start from popular problems, such as Sword for Offer and LeetCode Hot 100, and accumulate at least 100 questions to familiarize yourself with mainstream algorithmic problems. Forgetfulness can be a challenge when you start practicing, but rest assured that this is normal. We can follow the \"Ebbinghaus Forgetting Curve\" to review the questions, and usually after 3~5 rounds of repetitions, we will be able to memorize them.
    3. Stage 3: Building the knowledge system. In terms of learning, we can read algorithm column articles, solution frameworks, and algorithm textbooks to continuously enrich the knowledge system. In terms of practicing, we can try advanced strategies, such as categorizing by topic, multiple solutions for a single problem, and one solution for multiple problems, etc. Insights on these strategies can be found in various communities.

    As shown in the Figure 0-7 , this book mainly covers \u201cStage 1,\u201d aiming to help you more efficiently embark on Stages 2 and 3.

    Figure 0-7 \u00a0 Algorithm Learning Path

    "},{"location":"chapter_preface/summary/","title":"0.3 \u00a0 Summary","text":"
    • The main audience of this book is beginners in algorithm. If you already have some basic knowledge, this book can help you systematically review your algorithm knowledge, and the source code in this book can also be used as a \"Coding Toolkit\".
    • The book consists of three main sections, Complexity Analysis, Data Structures, and Algorithms, covering most of the topics in the field.
    • For newcomers to algorithms, it is crucial to read an introductory book in the beginning stages to avoid many detours or common pitfalls.
    • Animations and figures within the book are usually used to introduce key points and difficult knowledge. These should be given more attention when reading the book.
    • Practice is the best way to learn programming. It is highly recommended that you run the source code and type in the code yourself.
    • Each chapter in the web version of this book features a discussion section, and you are welcome to share your questions and insights at any time.
    "},{"location":"chapter_stack_and_queue/","title":"Chapter 5. \u00a0 Stack and Queue","text":"

    Abstract

    A stack is like cats placed on top of each other, while a queue is like cats lined up one by one.

    They represent the logical relationships of Last-In-First-Out (LIFO) and First-In-First-Out (FIFO), respectively.

    "},{"location":"chapter_stack_and_queue/#chapter-contents","title":"Chapter Contents","text":"
    • 5.1 \u00a0 Stack
    • 5.2 \u00a0 Queue
    • 5.3 \u00a0 Double-ended Queue
    • 5.4 \u00a0 Summary
    "},{"location":"chapter_stack_and_queue/deque/","title":"5.3 \u00a0 Double-Ended Queue","text":"

    In a queue, we can only delete elements from the head or add elements to the tail. As shown in the following diagram, a \"double-ended queue (deque)\" offers more flexibility, allowing the addition or removal of elements at both the head and the tail.

    Figure 5-7 \u00a0 Operations in Double-Ended Queue

    "},{"location":"chapter_stack_and_queue/deque/#531-common-operations-in-double-ended-queue","title":"5.3.1 \u00a0 Common Operations in Double-Ended Queue","text":"

    The common operations in a double-ended queue are listed below, and the names of specific methods depend on the programming language used.

    Table 5-3 \u00a0 Efficiency of Double-Ended Queue Operations

    Method Name Description Time Complexity pushFirst() Add an element to the head \\(O(1)\\) pushLast() Add an element to the tail \\(O(1)\\) popFirst() Remove the first element \\(O(1)\\) popLast() Remove the last element \\(O(1)\\) peekFirst() Access the first element \\(O(1)\\) peekLast() Access the last element \\(O(1)\\)

    Similarly, we can directly use the double-ended queue classes implemented in programming languages:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig deque.py
    from collections import deque\n\n# Initialize the deque\ndeque: deque[int] = deque()\n\n# Enqueue elements\ndeque.append(2)      # Add to the tail\ndeque.append(5)\ndeque.append(4)\ndeque.appendleft(3)  # Add to the head\ndeque.appendleft(1)\n\n# Access elements\nfront: int = deque[0]  # The first element\nrear: int = deque[-1]  # The last element\n\n# Dequeue elements\npop_front: int = deque.popleft()  # The first element dequeued\npop_rear: int = deque.pop()       # The last element dequeued\n\n# Get the length of the deque\nsize: int = len(deque)\n\n# Check if the deque is empty\nis_empty: bool = len(deque) == 0\n
    deque.cpp
    /* Initialize the deque */\ndeque<int> deque;\n\n/* Enqueue elements */\ndeque.push_back(2);   // Add to the tail\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // Add to the head\ndeque.push_front(1);\n\n/* Access elements */\nint front = deque.front(); // The first element\nint back = deque.back();   // The last element\n\n/* Dequeue elements */\ndeque.pop_front();  // The first element dequeued\ndeque.pop_back();   // The last element dequeued\n\n/* Get the length of the deque */\nint size = deque.size();\n\n/* Check if the deque is empty */\nbool empty = deque.empty();\n
    deque.java
    /* Initialize the deque */\nDeque<Integer> deque = new LinkedList<>();\n\n/* Enqueue elements */\ndeque.offerLast(2);   // Add to the tail\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // Add to the head\ndeque.offerFirst(1);\n\n/* Access elements */\nint peekFirst = deque.peekFirst();  // The first element\nint peekLast = deque.peekLast();    // The last element\n\n/* Dequeue elements */\nint popFirst = deque.pollFirst();  // The first element dequeued\nint popLast = deque.pollLast();    // The last element dequeued\n\n/* Get the length of the deque */\nint size = deque.size();\n\n/* Check if the deque is empty */\nboolean isEmpty = deque.isEmpty();\n
    deque.cs
    /* Initialize the deque */\n// In C#, LinkedList is used as a deque\nLinkedList<int> deque = new();\n\n/* Enqueue elements */\ndeque.AddLast(2);   // Add to the tail\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // Add to the head\ndeque.AddFirst(1);\n\n/* Access elements */\nint peekFirst = deque.First.Value;  // The first element\nint peekLast = deque.Last.Value;    // The last element\n\n/* Dequeue elements */\ndeque.RemoveFirst();  // The first element dequeued\ndeque.RemoveLast();   // The last element dequeued\n\n/* Get the length of the deque */\nint size = deque.Count;\n\n/* Check if the deque is empty */\nbool isEmpty = deque.Count == 0;\n
    deque_test.go
    /* Initialize the deque */\n// In Go, use list as a deque\ndeque := list.New()\n\n/* Enqueue elements */\ndeque.PushBack(2)      // Add to the tail\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // Add to the head\ndeque.PushFront(1)\n\n/* Access elements */\nfront := deque.Front() // The first element\nrear := deque.Back()   // The last element\n\n/* Dequeue elements */\ndeque.Remove(front)    // The first element dequeued\ndeque.Remove(rear)     // The last element dequeued\n\n/* Get the length of the deque */\nsize := deque.Len()\n\n/* Check if the deque is empty */\nisEmpty := deque.Len() == 0\n
    deque.swift
    /* Initialize the deque */\n// Swift does not have a built-in deque class, so Array can be used as a deque\nvar deque: [Int] = []\n\n/* Enqueue elements */\ndeque.append(2) // Add to the tail\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // Add to the head\ndeque.insert(1, at: 0)\n\n/* Access elements */\nlet peekFirst = deque.first! // The first element\nlet peekLast = deque.last!   // The last element\n\n/* Dequeue elements */\n// Using Array, popFirst has a complexity of O(n)\nlet popFirst = deque.removeFirst() // The first element dequeued\nlet popLast = deque.removeLast()   // The last element dequeued\n\n/* Get the length of the deque */\nlet size = deque.count\n\n/* Check if the deque is empty */\nlet isEmpty = deque.isEmpty\n
    deque.js
    /* Initialize the deque */\n// JavaScript does not have a built-in deque, so Array is used as a deque\nconst deque = [];\n\n/* Enqueue elements */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Note that unshift() has a time complexity of O(n) as it's an array\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Access elements */\nconst peekFirst = deque[0]; // The first element\nconst peekLast = deque[deque.length - 1]; // The last element\n\n/* Dequeue elements */\n// Note that shift() has a time complexity of O(n) as it's an array\nconst popFront = deque.shift(); // The first element dequeued\nconst popBack = deque.pop();    // The last element dequeued\n\n/* Get the length of the deque */\nconst size = deque.length;\n\n/* Check if the deque is empty */\nconst isEmpty = size === 0;\n
    deque.ts
    /* Initialize the deque */\n// TypeScript does not have a built-in deque, so Array is used as a deque\nconst deque: number[] = [];\n\n/* Enqueue elements */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Note that unshift() has a time complexity of O(n) as it's an array\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Access elements */\nconst peekFirst: number = deque[0]; // The first element\nconst peekLast: number = deque[deque.length - 1]; // The last element\n\n/* Dequeue elements */\n// Note that shift() has a time complexity of O(n) as it's an array\nconst popFront: number = deque.shift() as number; // The first element dequeued\nconst popBack: number = deque.pop() as number;    // The last element dequeued\n\n/* Get the length of the deque */\nconst size: number = deque.length;\n\n/* Check if the deque is empty */\nconst isEmpty: boolean = size === 0;\n
    deque.dart
    /* Initialize the deque */\n// In Dart, Queue is defined as a deque\nQueue<int> deque = Queue<int>();\n\n/* Enqueue elements */\ndeque.addLast(2);  // Add to the tail\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // Add to the head\ndeque.addFirst(1);\n\n/* Access elements */\nint peekFirst = deque.first; // The first element\nint peekLast = deque.last;   // The last element\n\n/* Dequeue elements */\nint popFirst = deque.removeFirst(); // The first element dequeued\nint popLast = deque.removeLast();   // The last element dequeued\n\n/* Get the length of the deque */\nint size = deque.length;\n\n/* Check if the deque is empty */\nbool isEmpty = deque.isEmpty;\n
    deque.rs
    /* Initialize the deque */\nlet mut deque: VecDeque<u32> = VecDeque::new();\n\n/* Enqueue elements */\ndeque.push_back(2);  // Add to the tail\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // Add to the head\ndeque.push_front(1);\n\n/* Access elements */\nif let Some(front) = deque.front() { // The first element\n}\nif let Some(rear) = deque.back() {   // The last element\n}\n\n/* Dequeue elements */\nif let Some(pop_front) = deque.pop_front() { // The first element dequeued\n}\nif let Some(pop_rear) = deque.pop_back() {   // The last element dequeued\n}\n\n/* Get the length of the deque */\nlet size = deque.len();\n\n/* Check if the deque is empty */\nlet is_empty = deque.is_empty();\n
    deque.c
    // C does not provide a built-in deque\n
    deque.kt
    \n
    deque.zig
    \n
    Visualizing Code

    https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%0A%20%20%20%20deq%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20deq.append%282%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E5%B0%BE%0A%20%20%20%20deq.append%285%29%0A%20%20%20%20deq.append%284%29%0A%20%20%20%20deq.appendleft%283%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E9%A6%96%0A%20%20%20%20deq.appendleft%281%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20deq%5B0%5D%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%20%20%20%20rear%20%3D%20deq%5B-1%5D%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%20rear%20%3D%22,%20rear%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop_front%20%3D%20deq.popleft%28%29%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_front%20%3D%22,%20pop_front%29%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%20%20%20%20pop_rear%20%3D%20deq.pop%28%29%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_rear%20%3D%22,%20pop_rear%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28deq%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28deq%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false

    "},{"location":"chapter_stack_and_queue/deque/#532-implementing-a-double-ended-queue","title":"5.3.2 \u00a0 Implementing a Double-Ended Queue *","text":"

    The implementation of a double-ended queue is similar to that of a regular queue, it can be based on either a linked list or an array as the underlying data structure.

    "},{"location":"chapter_stack_and_queue/deque/#1-implementation-based-on-doubly-linked-list","title":"1. \u00a0 Implementation Based on Doubly Linked List","text":"

    Recall from the previous section that we used a regular singly linked list to implement a queue, as it conveniently allows for deleting from the head (corresponding to the dequeue operation) and adding new elements after the tail (corresponding to the enqueue operation).

    For a double-ended queue, both the head and the tail can perform enqueue and dequeue operations. In other words, a double-ended queue needs to implement operations in the opposite direction as well. For this, we use a \"doubly linked list\" as the underlying data structure of the double-ended queue.

    As shown in the Figure 5-8 , we treat the head and tail nodes of the doubly linked list as the front and rear of the double-ended queue, respectively, and implement the functionality to add and remove nodes at both ends.

    LinkedListDequepushLast()pushFirst()popLast()popFirst()

    Figure 5-8 \u00a0 Implementing Double-Ended Queue with Doubly Linked List for Enqueue and Dequeue Operations

    The implementation code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_deque.py
    class ListNode:\n    \"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n        self.prev: ListNode | None = None  # \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\nclass LinkedListDeque:\n    \"\"\"\u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._front: ListNode | None = None  # \u5934\u8282\u70b9 front\n        self._rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\n        self._size: int = 0  # \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self.size() == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"\u5165\u961f\u64cd\u4f5c\"\"\"\n        node = ListNode(num)\n        # \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if self.is_empty():\n            self._front = self._rear = node\n        # \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        elif is_front:\n            # \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            self._front.prev = node\n            node.next = self._front\n            self._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\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # \u66f4\u65b0\u5c3e\u8282\u70b9\n        self._size += 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n\n    def push_first(self, num: int):\n        \"\"\"\u961f\u9996\u5165\u961f\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -> int:\n        \"\"\"\u51fa\u961f\u64cd\u4f5c\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        # \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if is_front:\n            val: int = self._front.val  # \u6682\u5b58\u5934\u8282\u70b9\u503c\n            # \u5220\u9664\u5934\u8282\u70b9\n            fnext: ListNode | None = self._front.next\n            if fnext != None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # \u66f4\u65b0\u5934\u8282\u70b9\n        # \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else:\n            val: int = self._rear.val  # \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            # \u5220\u9664\u5c3e\u8282\u70b9\n            rprev: ListNode | None = self._rear.prev\n            if rprev != None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # \u66f4\u65b0\u5c3e\u8282\u70b9\n        self._size -= 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val\n\n    def pop_first(self) -> int:\n        \"\"\"\u961f\u9996\u51fa\u961f\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -> int:\n        \"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._front.val\n\n    def peek_last(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._rear.val\n\n    def to_array(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n
    linkedlist_deque.cpp
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nstruct DoublyListNode {\n    int val;              // \u8282\u70b9\u503c\n    DoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n    DoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\u6307\u9488\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize = 0;              // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~LinkedListDeque() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur->next;\n            delete pre;\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty())\n            front = rear = node;\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front->prev = node;\n            node->next = front;\n            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\n            rear->next = node;\n            node->prev = rear;\n            rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        int val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front->val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            DoublyListNode *fNext = front->next;\n            if (fNext != nullptr) {\n                fNext->prev = nullptr;\n                front->next = nullptr;\n            }\n            delete front;\n            front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            val = rear->val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            DoublyListNode *rPrev = rear->prev;\n            if (rPrev != nullptr) {\n                rPrev->next = nullptr;\n                rear->prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return front->val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return rear->val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        DoublyListNode *node = front;\n        vector<int> res(size());\n        for (int i = 0; i < res.size(); i++) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_deque.java
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    int val; // \u8282\u70b9\u503c\n    ListNode next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    ListNode prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private int queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty())\n            front = rear = node;\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front.prev = node;\n            node.next = front;\n            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\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            val = rear.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_deque.cs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode(int val) {\n    public int val = val;       // \u8282\u70b9\u503c\n    public ListNode? next = null; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    public ListNode? prev = null; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    ListNode? front, rear; // \u5934\u8282\u70b9 front, \u5c3e\u8282\u70b9 rear\n    int queSize = 0;      // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front!.prev = node;\n            node.next = front;\n            front = node; // \u66f4\u65b0\u5934\u8282\u70b9                           \n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front?.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            val = rear?.val;  // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i < res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u53cc\u7aef\u961f\u5217 */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* \u961f\u9996\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* \u961f\u5c3e\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* \u961f\u9996\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u961f\u5c3e\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n
    linkedlist_deque.swift
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    var val: Int // \u8282\u70b9\u503c\n    var next: ListNode? // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    weak var prev: ListNode? // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private var front: ListNode? // \u5934\u8282\u70b9 front\n    private var rear: ListNode? // \u5c3e\u8282\u70b9 rear\n    private var _size: Int // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if isFront {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front?.prev = node\n            node.next = front\n            front = node // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            rear?.next = node\n            node.prev = rear\n            rear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        _size += 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    private func pop(isFront: Bool) -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        let val: Int\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if isFront {\n            val = front!.val // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            val = rear!.val // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        _size -= 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    func popFirst() -> Int {\n        pop(isFront: true)\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    func popLast() -> Int {\n        pop(isFront: false)\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peekFirst() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return front!.val\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    func peekLast() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return rear!.val\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    func toArray() -> [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n
    linkedlist_deque.js
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    val; // \u8282\u70b9\u503c\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\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\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        this.#queSize++;\n    }\n\n    /* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        this.#queSize++;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5c3e\u8282\u70b9\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        this.#queSize--;\n        return value;\n    }\n\n    /* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5934\u8282\u70b9\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\n        this.#queSize--;\n        return value;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u6253\u5370\u53cc\u5411\u961f\u5217 */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n
    linkedlist_deque.ts
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    prev: ListNode; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    next: ListNode; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    val: number; // \u8282\u70b9\u503c\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private front: ListNode; // \u5934\u8282\u70b9 front\n    private rear: ListNode; // \u5c3e\u8282\u70b9 rear\n    private queSize: number; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        this.queSize++;\n    }\n\n    /* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        this.queSize++;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5c3e\u8282\u70b9\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        this.queSize--;\n        return value;\n    }\n\n    /* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5934\u8282\u70b9\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\n        this.queSize--;\n        return value;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u6253\u5370\u53cc\u5411\u961f\u5217 */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n
    linkedlist_deque.dart
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n  int val; // \u8282\u70b9\u503c\n  ListNode? next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n  ListNode? prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u5bf9\u5217 */\nclass LinkedListDeque {\n  late ListNode? _front; // \u5934\u8282\u70b9 _front\n  late ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\n  int _queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u957f\u5ea6 */\n  int size() {\n    return this._queSize;\n  }\n\n  /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* \u5165\u961f\u64cd\u4f5c */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 _front \u548c _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;\n      node.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;\n      node.prev = _rear;\n      _rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    _queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n  }\n\n  /* \u961f\u9996\u5165\u961f */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* \u961f\u5c3e\u5165\u961f */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* \u51fa\u961f\u64cd\u4f5c */\n  int? pop(bool isFront) {\n    // \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n      val = _front!.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n      // \u5220\u9664\u5934\u8282\u70b9\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n    } else {\n      // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n      val = _rear!.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n      // \u5220\u9664\u5c3e\u8282\u70b9\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    _queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    return val;\n  }\n\n  /* \u961f\u9996\u51fa\u961f */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* \u961f\u5c3e\u51fa\u961f */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n  List<int> toArray() {\n    ListNode? node = _front;\n    final List<int> res = [];\n    for (int i = 0; i < _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n
    linkedlist_deque.rs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\npub struct ListNode<T> {\n    pub val: T,                                 // \u8282\u70b9\u503c\n    pub next: Option<Rc<RefCell<ListNode<T>>>>, // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n    pub prev: Option<Rc<RefCell<ListNode<T>>>>, // \u524d\u9a71\u8282\u70b9\u6307\u9488\n}\n\nimpl<T> ListNode<T> {\n    pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\n#[allow(dead_code)]\npub struct LinkedListDeque<T> {\n    front: Option<Rc<RefCell<ListNode<T>>>>, // \u5934\u8282\u70b9 front\n    rear: Option<Rc<RefCell<ListNode<T>>>>,  // \u5c3e\u8282\u70b9 rear\n    que_size: usize,                         // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListDeque<T> {\n    pub fn new() -> Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.que_size;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    pub fn push(&mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        if is_front {\n            match self.front.take() {\n                // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n                None => {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n                Some(old_front) => {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // \u66f4\u65b0\u5934\u8282\u70b9\n                }\n            }\n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            match self.rear.take() {\n                // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n                None => {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n                Some(old_rear) => {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // \u66f4\u65b0\u5c3e\u8282\u70b9\n                }\n            }\n        }\n        self.que_size += 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pub fn push_first(&mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pub fn push_last(&mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    pub fn pop(&mut self, is_front: bool) -> Option<T> {\n        // \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de None\n        if self.is_empty() {\n            return None;\n        };\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) => {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // \u66f4\u65b0\u5934\u8282\u70b9\n                    }\n                    None => {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n                Rc::try_unwrap(old_front).ok().unwrap().into_inner().val\n            })\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) => {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // \u66f4\u65b0\u5c3e\u8282\u70b9\n                    }\n                    None => {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n                Rc::try_unwrap(old_rear).ok().unwrap().into_inner().val\n            })\n        }\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    pub fn pop_first(&mut self) -> Option<T> {\n        return self.pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    pub fn pop_last(&mut self) -> Option<T> {\n        return self.pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    pub fn peek_first(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.front.as_ref()\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    pub fn peek_last(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.rear.as_ref()\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.insert(0, node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_deque.c
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\ntypedef struct DoublyListNode {\n    int val;                     // \u8282\u70b9\u503c\n    struct DoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\n    struct DoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\n} DoublyListNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new->val = num;\n    new->next = NULL;\n    new->prev = NULL;\n    return new;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntypedef struct {\n    DoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize;                  // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n} LinkedListDeque;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque->front = NULL;\n    deque->rear = NULL;\n    deque->queSize = 0;\n    return deque;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // \u91ca\u653e\u6240\u6709\u8282\u70b9\n    for (int i = 0; i < deque->queSize && deque->front != NULL; i++) {\n        DoublyListNode *tmp = deque->front;\n        deque->front = deque->front->next;\n        free(tmp);\n    }\n    // \u91ca\u653e deque \u7ed3\u6784\u4f53\n    free(deque);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(LinkedListDeque *deque) {\n    return deque->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* \u5165\u961f */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411node\n    if (empty(deque)) {\n        deque->front = deque->rear = node;\n    }\n    // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n    else if (isFront) {\n        // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n        deque->front->prev = node;\n        node->next = deque->front;\n        deque->front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n    }\n    // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n    else {\n        // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n        deque->rear->next = node;\n        node->prev = deque->rear;\n        deque->rear = node;\n    }\n    deque->queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) && deque->front);\n    return deque->front->val;\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) && deque->rear);\n    return deque->rear->val;\n}\n\n/* \u51fa\u961f */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n    if (isFront) {\n        val = peekFirst(deque); // \u6682\u5b58\u5934\u8282\u70b9\u503c\n        DoublyListNode *fNext = deque->front->next;\n        if (fNext) {\n            fNext->prev = NULL;\n            deque->front->next = NULL;\n            delDoublyListNode(deque->front);\n        }\n        deque->front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n    }\n    // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n    else {\n        val = peekLast(deque); // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n        DoublyListNode *rPrev = deque->rear->prev;\n        if (rPrev) {\n            rPrev->next = NULL;\n            deque->rear->prev = NULL;\n            delDoublyListNode(deque->rear);\n        }\n        deque->rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    deque->queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    return val;\n}\n\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque->queSize);\n    // \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque->front; i < deque->queSize; i++) {\n        arr[i] = node->val;\n        node = node->next;\n    }\n    printArray(arr, deque->queSize);\n    free(arr);\n}\n
    linkedlist_deque.kt
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode(var value: Int) {\n    // \u8282\u70b9\u503c\n    var next: ListNode? = null // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    var prev: ListNode? = null // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private var front: ListNode? = null // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private var rear: ListNode? = null\n    private var queSize = 0 // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        } else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front?.prev = node\n            node.next = front\n            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\n            rear?.next = node\n            node.prev = rear\n            rear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++ // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n\n        val value: Int\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            value = front!!.value // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n            // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            value = rear!!.value // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize-- // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return value\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peekFirst(): Int {\n        if (isEmpty()) {\n            throw IndexOutOfBoundsException()\n\n        }\n        return front!!.value\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!.value\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!.value\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_deque.rb
    [class]{ListNode}-[func]{}\n\n[class]{LinkedListDeque}-[func]{}\n
    linkedlist_deque.zig
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\nfn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = undefined,     // \u8282\u70b9\u503c\n        next: ?*Self = null,    // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n        prev: ?*Self = null,    // \u524d\u9a71\u8282\u70b9\u6307\u9488\n\n        // Initialize a list node with specific value\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n            self.prev = null;\n        }\n    };\n}\n\n// \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\nfn LinkedListDeque(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        front: ?*ListNode(T) = null,                    // \u5934\u8282\u70b9 front\n        rear: ?*ListNode(T) = null,                     // \u5c3e\u8282\u70b9 rear\n        que_size: usize = 0,                             // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.front = null;\n            self.rear = null;\n            self.que_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.que_size;\n        }\n\n        // \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u5165\u961f\u64cd\u4f5c\n        pub fn push(self: *Self, num: T, is_front: bool) !void {\n            var node = try self.mem_allocator.create(ListNode(T));\n            node.init(num);\n            // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n            if (self.isEmpty()) {\n                self.front = node;\n                self.rear = node;\n            // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n            } else if (is_front) {\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n                self.front.?.prev = node;\n                node.next = self.front;\n                self.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\n                self.rear.?.next = node;\n                node.prev = self.rear;\n                self.rear = node;   // \u66f4\u65b0\u5c3e\u8282\u70b9\n            }\n            self.que_size += 1;      // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        } \n\n        // \u961f\u9996\u5165\u961f\n        pub fn pushFirst(self: *Self, num: T) !void {\n            try self.push(num, true);\n        } \n\n        // \u961f\u5c3e\u5165\u961f\n        pub fn pushLast(self: *Self, num: T) !void {\n            try self.push(num, false);\n        } \n\n        // \u51fa\u961f\u64cd\u4f5c\n        pub fn pop(self: *Self, is_front: bool) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            var val: T = undefined;\n            // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n            if (is_front) {\n                val = self.front.?.val;     // \u6682\u5b58\u5934\u8282\u70b9\u503c\n                // \u5220\u9664\u5934\u8282\u70b9\n                var fNext = self.front.?.next;\n                if (fNext != null) {\n                    fNext.?.prev = null;\n                    self.front.?.next = null;\n                }\n                self.front = fNext;         // \u66f4\u65b0\u5934\u8282\u70b9\n            // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n            } else {\n                val = self.rear.?.val;      // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n                // \u5220\u9664\u5c3e\u8282\u70b9\n                var rPrev = self.rear.?.prev;\n                if (rPrev != null) {\n                    rPrev.?.next = null;\n                    self.rear.?.prev = null;\n                }\n                self.rear = rPrev;          // \u66f4\u65b0\u5c3e\u8282\u70b9\n            }\n            self.que_size -= 1;              // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n            return val;\n        } \n\n        // \u961f\u9996\u51fa\u961f\n        pub fn popFirst(self: *Self) T {\n            return self.pop(true);\n        } \n\n        // \u961f\u5c3e\u51fa\u961f\n        pub fn popLast(self: *Self) T {\n            return self.pop(false);\n        } \n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peekFirst(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            return self.front.?.val;\n        }  \n\n        // \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\n        pub fn peekLast(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            return self.rear.?.val;\n        }\n\n        // \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.front;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[i] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    "},{"location":"chapter_stack_and_queue/deque/#2-implementation-based-on-array","title":"2. \u00a0 Implementation Based on Array","text":"

    As shown in the Figure 5-9 , similar to implementing a queue with an array, we can also use a circular array to implement a double-ended queue.

    ArrayDequepushLast()pushFirst()popLast()popFirst()

    Figure 5-9 \u00a0 Implementing Double-Ended Queue with Array for Enqueue and Dequeue Operations

    The implementation only needs to add methods for \"front enqueue\" and \"rear dequeue\":

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_deque.py
    class ArrayDeque:\n    \"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\n        return len(self._nums)\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._size == 0\n\n    def 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\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"\u961f\u9996\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        # \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        # \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        self._front = self.index(self._front - 1)\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        # \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        rear = self.index(self._front + self._size)\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -> int:\n        \"\"\"\u961f\u9996\u51fa\u961f\"\"\"\n        num = self.peek_first()\n        # \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -> int:\n        \"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._nums[self._front]\n\n    def peek_last(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        # \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def 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\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n
    array_deque.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n  private:\n    vector<int> nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;      // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    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\n        return (i + capacity()) % capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    int popFirst() {\n        int num = peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> res(queSize);\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n
    array_deque.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private int[] nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private 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\n        return (i + capacity()) % capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int popFirst() {\n        int num = peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    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\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = Index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntype arrayDeque struct {\n    nums        []int // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    queSize     int   // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n    queCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\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\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* \u961f\u9996\u5165\u961f */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n        return\n    }\n    // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n    q.front = q.index(q.front - 1)\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n        return\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    rear := q.index(q.front + q.queSize)\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* \u961f\u9996\u51fa\u961f */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    q.queSize--\n    return num\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\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\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i < q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n
    array_deque.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var _size: Int // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    func capacity() -> Int {\n        nums.count\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private 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\n    /* \u961f\u9996\u5165\u961f */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        front = index(i: front - 1)\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        nums[front] = num\n        _size += 1\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        let rear = index(i: front + size())\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    func popFirst() -> Int {\n        let num = peekFirst()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    func popLast() -> Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peekFirst() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return nums[front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    func peekLast() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    func toArray() -> [Int] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        (front ..< front + size()).map { nums[index(i: $0)] }\n    }\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\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    index(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\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        this.#front = this.index(this.#front - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        const rear = this.index(this.#front + this.#queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    popFirst() {\n        const num = this.peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const res = [];\n        for (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private queSize: number; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    index(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\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        this.front = this.index(this.front - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        const rear: number = this.index(this.front + this.queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    toArray(): number[] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i < this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n  late List<int> _nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n  late int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n  late int _queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n  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\n    return (i + capacity()) % capacity();\n  }\n\n  /* \u961f\u9996\u5165\u961f */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw 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\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\n  /* \u961f\u5c3e\u5165\u961f */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    int rear = index(_front + _queSize);\n    // \u5c06 _num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* \u961f\u9996\u51fa\u961f */\n  int popFirst() {\n    int _num = peekFirst();\n    // \u961f\u9996\u6307\u9488\u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* \u961f\u5c3e\u51fa\u961f */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n    }\n    return _nums[_front];\n  }\n\n  /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n    }\n    // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n  List<int> toArray() {\n    // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    List<int> res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i < _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n
    array_deque.rs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nstruct ArrayDeque {\n    nums: Vec<i32>,  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front: usize,    // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    que_size: usize, // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n}\n\nimpl ArrayDeque {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(capacity: usize) -> Self {\n        Self {\n            nums: vec![0; capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    pub fn capacity(&self) -> usize {\n        self.nums.len()\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        self.que_size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        self.que_size == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    fn index(&self, i: i32) -> usize {\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        return ((i + self.capacity() as i32) % self.capacity() as i32) as usize;\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pub fn push_first(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        self.front = self.index(self.front as i32 - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pub fn push_last(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fn pop_first(&mut self) -> i32 {\n        let num = self.peek_first();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    fn pop_last(&mut self) -> i32 {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fn peek_first(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        };\n        self.nums[self.front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fn peek_last(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        };\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fn to_array(&self) -> Vec<i32> {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        let mut res = vec![0; self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n
    array_deque.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntypedef struct {\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n} ArrayDeque;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // \u521d\u59cb\u5316\u6570\u7ec4\n    deque->queCapacity = capacity;\n    deque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);\n    deque->front = deque->queSize = 0;\n    return deque;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque->nums);\n    free(deque);\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(ArrayDeque *deque) {\n    return deque->queCapacity;\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size(ArrayDeque *deque) {\n    return deque->queSize;\n}\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(ArrayDeque *deque) {\n    return deque->queSize == 0;\n}\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\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque->queSize == capacity(deque)) {\n        printf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u56de\u5230\u5c3e\u90e8\n    deque->front = dequeIndex(deque, deque->front - 1);\n    // \u5c06 num \u6dfb\u52a0\u5230\u961f\u9996\n    deque->nums[deque->front] = num;\n    deque->queSize++;\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque->queSize == capacity(deque)) {\n        printf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    int rear = dequeIndex(deque, deque->front + deque->queSize);\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    deque->nums[rear] = num;\n    deque->queSize++;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(ArrayDeque *deque) {\n    // \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\n    assert(empty(deque) == 0);\n    return deque->nums[deque->front];\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(ArrayDeque *deque) {\n    // \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque->front + deque->queSize - 1);\n    return deque->nums[last];\n}\n\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    deque->front = dequeIndex(deque, deque->front + 1);\n    deque->queSize--;\n    return num;\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque->queSize--;\n    return num;\n}\n
    array_deque.kt
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque(capacity: Int) {\n    private var nums = IntArray(capacity) // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var queSize = 0 // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private fun 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        return (i + capacity()) % capacity()\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        val rear = index(front + queSize)\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        queSize++\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fun toArray(): IntArray {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i < queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n
    array_deque.rb
    [class]{ArrayDeque}-[func]{}\n
    array_deque.zig
    [class]{ArrayDeque}-[func]{}\n
    "},{"location":"chapter_stack_and_queue/deque/#533-applications-of-double-ended-queue","title":"5.3.3 \u00a0 Applications of Double-Ended Queue","text":"

    The double-ended queue combines the logic of both stacks and queues, thus, it can implement all their respective use cases while offering greater flexibility.

    We know that software's \"undo\" feature is typically implemented using a stack: the system pushes each change operation onto the stack and then pops to implement undoing. However, considering the limitations of system resources, software often restricts the number of undo steps (for example, only allowing the last 50 steps). When the stack length exceeds 50, the software needs to perform a deletion operation at the bottom of the stack (the front of the queue). But a regular stack cannot perform this function, where a double-ended queue becomes necessary. Note that the core logic of \"undo\" still follows the Last-In-First-Out principle of a stack, but a double-ended queue can more flexibly implement some additional logic.

    "},{"location":"chapter_stack_and_queue/queue/","title":"5.2 \u00a0 Queue","text":"

    \"Queue\" is a linear data structure that follows the First-In-First-Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers join the queue at the rear, and the person at the front leaves the queue first.

    As shown in the Figure 5-4 , we call the front of the queue the \"head\" and the back the \"tail.\" The operation of adding elements to the rear of the queue is termed \"enqueue,\" and the operation of removing elements from the front is termed \"dequeue.\"

    Figure 5-4 \u00a0 Queue's First-In-First-Out Rule

    "},{"location":"chapter_stack_and_queue/queue/#521-common-operations-on-queue","title":"5.2.1 \u00a0 Common Operations on Queue","text":"

    The common operations on a queue are shown in the Table 5-2 . Note that method names may vary across different programming languages. Here, we use the same naming convention as that used for stacks.

    Table 5-2 \u00a0 Efficiency of Queue Operations

    Method Name Description Time Complexity push() Enqueue an element, add it to the tail \\(O(1)\\) pop() Dequeue the head element \\(O(1)\\) peek() Access the head element \\(O(1)\\)

    We can directly use the ready-made queue classes in programming languages:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig queue.py
    from collections import deque\n\n# Initialize the queue\n# In Python, we generally use the deque class as a queue\n# Although queue.Queue() is a pure queue class, it's not very user-friendly, so it's not recommended\nque: deque[int] = deque()\n\n# Enqueue elements\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# Access the first element\nfront: int = que[0]\n\n# Dequeue an element\npop: int = que.popleft()\n\n# Get the length of the queue\nsize: int = len(que)\n\n# Check if the queue is empty\nis_empty: bool = len(que) == 0\n
    queue.cpp
    /* Initialize the queue */\nqueue<int> queue;\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access the first element*/\nint front = queue.front();\n\n/* Dequeue an element */\nqueue.pop();\n\n/* Get the length of the queue */\nint size = queue.size();\n\n/* Check if the queue is empty */\nbool empty = queue.empty();\n
    queue.java
    /* Initialize the queue */\nQueue<Integer> queue = new LinkedList<>();\n\n/* Enqueue elements */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* Access the first element */\nint peek = queue.peek();\n\n/* Dequeue an element */\nint pop = queue.poll();\n\n/* Get the length of the queue */\nint size = queue.size();\n\n/* Check if the queue is empty */\nboolean isEmpty = queue.isEmpty();\n
    queue.cs
    /* Initialize the queue */\nQueue<int> queue = new();\n\n/* Enqueue elements */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* Access the first element */\nint peek = queue.Peek();\n\n/* Dequeue an element */\nint pop = queue.Dequeue();\n\n/* Get the length of the queue */\nint size = queue.Count;\n\n/* Check if the queue is empty */\nbool isEmpty = queue.Count == 0;\n
    queue_test.go
    /* Initialize the queue */\n// In Go, use list as a queue\nqueue := list.New()\n\n/* Enqueue elements */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* Access the first element */\npeek := queue.Front()\n\n/* Dequeue an element */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* Get the length of the queue */\nsize := queue.Len()\n\n/* Check if the queue is empty */\nisEmpty := queue.Len() == 0\n
    queue.swift
    /* Initialize the queue */\n// Swift does not have a built-in queue class, so Array can be used as a queue\nvar queue: [Int] = []\n\n/* Enqueue elements */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* Access the first element */\nlet peek = queue.first!\n\n/* Dequeue an element */\n// Since it's an array, removeFirst has a complexity of O(n)\nlet pool = queue.removeFirst()\n\n/* Get the length of the queue */\nlet size = queue.count\n\n/* Check if the queue is empty */\nlet isEmpty = queue.isEmpty\n
    queue.js
    /* Initialize the queue */\n// JavaScript does not have a built-in queue, so Array can be used as a queue\nconst queue = [];\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access the first element */\nconst peek = queue[0];\n\n/* Dequeue an element */\n// Since the underlying structure is an array, shift() method has a time complexity of O(n)\nconst pop = queue.shift();\n\n/* Get the length of the queue */\nconst size = queue.length;\n\n/* Check if the queue is empty */\nconst empty = queue.length === 0;\n
    queue.ts
    /* Initialize the queue */\n// TypeScript does not have a built-in queue, so Array can be used as a queue \nconst queue: number[] = [];\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access the first element */\nconst peek = queue[0];\n\n/* Dequeue an element */\n// Since the underlying structure is an array, shift() method has a time complexity of O(n)\nconst pop = queue.shift();\n\n/* Get the length of the queue */\nconst size = queue.length;\n\n/* Check if the queue is empty */\nconst empty = queue.length === 0;\n
    queue.dart
    /* Initialize the queue */\n// In Dart, the Queue class is a double-ended queue but can be used as a queue\nQueue<int> queue = Queue();\n\n/* Enqueue elements */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* Access the first element */\nint peek = queue.first;\n\n/* Dequeue an element */\nint pop = queue.removeFirst();\n\n/* Get the length of the queue */\nint size = queue.length;\n\n/* Check if the queue is empty */\nbool isEmpty = queue.isEmpty;\n
    queue.rs
    /* Initialize the double-ended queue */\n// In Rust, use a double-ended queue as a regular queue\nlet mut deque: VecDeque<u32> = VecDeque::new();\n\n/* Enqueue elements */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* Access the first element */\nif let Some(front) = deque.front() {\n}\n\n/* Dequeue an element */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* Get the length of the queue */\nlet size = deque.len();\n\n/* Check if the queue is empty */\nlet is_empty = deque.is_empty();\n
    queue.c
    // C does not provide a built-in queue\n
    queue.kt
    \n
    queue.zig
    \n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/queue/#522-implementing-a-queue","title":"5.2.2 \u00a0 Implementing a Queue","text":"

    To implement a queue, we need a data structure that allows adding elements at one end and removing them at the other. Both linked lists and arrays meet this requirement.

    "},{"location":"chapter_stack_and_queue/queue/#1-implementation-based-on-a-linked-list","title":"1. \u00a0 Implementation Based on a Linked List","text":"

    As shown in the Figure 5-5 , we can consider the \"head node\" and \"tail node\" of a linked list as the \"front\" and \"rear\" of the queue, respectively. It is stipulated that nodes can only be added at the rear and removed at the front.

    LinkedListQueuepush()pop()

    Figure 5-5 \u00a0 Implementing Queue with Linked List for Enqueue and Dequeue Operations

    Below is the code for implementing a queue using a linked list:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_queue.py
    class LinkedListQueue:\n    \"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._front: ListNode | None = None  # \u5934\u8282\u70b9 front\n        self._rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\n        self._size: int = 0\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return not self._front\n\n    def push(self, num: int):\n        \"\"\"\u5165\u961f\"\"\"\n        # \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        node = ListNode(num)\n        # \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if self._front is None:\n            self._front = node\n            self._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:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u961f\"\"\"\n        num = self.peek()\n        # \u5220\u9664\u5934\u8282\u70b9\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\n        return self._front.val\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n
    linkedlist_queue.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        freeMemoryLinkedList(front);\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    void push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode *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\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n        else {\n            rear->next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    int pop() {\n        int num = peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        ListNode *tmp = front;\n        front = front->next;\n        // \u91ca\u653e\u5185\u5b58\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        return front->val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        ListNode *node = front;\n        vector<int> res(size());\n        for (int i = 0; i < res.size(); i++) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_queue.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f */\n    public void push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode 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\n        if (front == null) {\n            front = node;\n            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 {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int pop() {\n        int num = peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    ListNode? front, rear;  // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear \n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u961f */\n    public void Push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode node = new(num);\n        // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if (front == null) {\n            front = node;\n            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 if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int Pop() {\n        int num = Peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i < res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* \u5165\u961f */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* \u51fa\u961f */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n
    linkedlist_queue.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private var front: ListNode? // \u5934\u8282\u70b9\n    private var rear: ListNode? // \u5c3e\u8282\u70b9\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f */\n    func push(num: Int) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        let 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\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* \u51fa\u961f */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return front!.val\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\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;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        const 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\n        if (!this.#front) {\n            this.#front = node;\n            this.#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 {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop() {\n        const num = this.peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek() {\n        if (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.#front.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private front: ListNode | null; // \u5934\u8282\u70b9 front\n    private rear: ListNode | null; // \u5c3e\u8282\u70b9 rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num: number): void {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        const 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\n        if (!this.front) {\n            this.front = node;\n            this.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 {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        // \u5220\u9664\u5934\u8282\u70b9\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek(): number {\n        if (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.front!.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array<number>(this.size);\n        for (let i = 0; i < res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.dart
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n  ListNode? _front; // \u5934\u8282\u70b9 _front\n  ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\n  int _queSize = 0; // \u961f\u5217\u957f\u5ea6\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u5165\u961f */\n  void push(int _num) {\n    // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 _num\n    final node = ListNode(_num);\n    // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n    if (_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\n  /* \u51fa\u961f */\n  int pop() {\n    final int _num = peek();\n    // \u5220\u9664\u5934\u8282\u70b9\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('\u961f\u5217\u4e3a\u7a7a');\n    }\n    return _front!.val;\n  }\n\n  /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n  List<int> toArray() {\n    ListNode? node = _front;\n    final List<int> queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n
    linkedlist_queue.rs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\n#[allow(dead_code)]\npub struct LinkedListQueue<T> {\n    front: Option<Rc<RefCell<ListNode<T>>>>, // \u5934\u8282\u70b9 front\n    rear: Option<Rc<RefCell<ListNode<T>>>>,  // \u5c3e\u8282\u70b9 rear\n    que_size: usize,                         // \u961f\u5217\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListQueue<T> {\n    pub fn new() -> Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.que_size;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u961f */\n    pub fn push(&mut self, num: T) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n            Some(old_rear) => {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n            None => {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* \u51fa\u961f */\n    pub fn pop(&mut self) -> Option<T> {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) => {\n                    self.front = Some(new_front);\n                }\n                None => {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            Rc::try_unwrap(old_front).ok().unwrap().into_inner().val\n        })\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.front.as_ref()\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.insert(0, node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_queue.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue->front = NULL;\n    queue->rear = NULL;\n    queue->queSize = 0;\n    return queue;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // \u91ca\u653e\u6240\u6709\u8282\u70b9\n    while (queue->front != NULL) {\n        ListNode *tmp = queue->front;\n        queue->front = queue->front->next;\n        free(tmp);\n    }\n    // \u91ca\u653e queue \u7ed3\u6784\u4f53\n    free(queue);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(LinkedListQueue *queue) {\n    return queue->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* \u5165\u961f */\nvoid push(LinkedListQueue *queue, int num) {\n    // \u5c3e\u8282\u70b9\u5904\u6dfb\u52a0 node\n    ListNode *node = newListNode(num);\n    // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n    if (queue->front == NULL) {\n        queue->front = node;\n        queue->rear = node;\n    }\n    // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n    else {\n        queue->rear->next = node;\n        queue->rear = node;\n    }\n    queue->queSize++;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) && queue->front);\n    return queue->front->val;\n}\n\n/* \u51fa\u961f */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue->front;\n    queue->front = queue->front->next;\n    free(tmp);\n    queue->queSize--;\n    return num;\n}\n\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue->queSize);\n    // \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue->front; i < queue->queSize; i++) {\n        arr[i] = node->val;\n        node = node->next;\n    }\n    printArray(arr, queue->queSize);\n    free(arr);\n}\n
    linkedlist_queue.kt
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue(\n    // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u961f */\n    fun push(num: Int) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        val node = ListNode(num)\n        // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if (front == null) {\n            front = node\n            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 {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* \u51fa\u961f */\n    fun pop(): Int {\n        val num = peek()\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!.value\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!.value\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_queue.rb
    [class]{LinkedListQueue}-[func]{}\n
    linkedlist_queue.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\nfn LinkedListQueue(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        front: ?*inc.ListNode(T) = null,                // \u5934\u8282\u70b9 front\n        rear: ?*inc.ListNode(T) = null,                 // \u5c3e\u8282\u70b9 rear\n        que_size: usize = 0,                            // \u961f\u5217\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.front = null;\n            self.rear = null;\n            self.que_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.que_size;\n        }\n\n        // \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.size() == 0) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\n            return self.front.?.val;\n        }  \n\n        // \u5165\u961f\n        pub fn push(self: *Self, num: T) !void {\n            // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n            var node = try self.mem_allocator.create(inc.ListNode(T));\n            node.init(num);\n            // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n            if (self.front == null) {\n                self.front = node;\n                self.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 {\n                self.rear.?.next = node;\n                self.rear = node;\n            }\n            self.que_size += 1;\n        } \n\n        // \u51fa\u961f\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            // \u5220\u9664\u5934\u8282\u70b9\n            self.front = self.front.?.next;\n            self.que_size -= 1;\n            return num;\n        } \n\n        // \u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.front;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[i] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/queue/#2-implementation-based-on-an-array","title":"2. \u00a0 Implementation Based on an Array","text":"

    Deleting the first element in an array has a time complexity of \\(O(n)\\), which would make the dequeue operation inefficient. However, this problem can be cleverly avoided as follows.

    We use a variable front to indicate the index of the front element and maintain a variable size to record the queue's length. Define rear = front + size, which points to the position immediately following the tail element.

    With this design, the effective interval of elements in the array is [front, rear - 1]. The implementation methods for various operations are shown in the Figure 5-6 .

    • Enqueue operation: Assign the input element to the rear index and increase size by 1.
    • Dequeue operation: Simply increase front by 1 and decrease size by 1.

    Both enqueue and dequeue operations only require a single operation, each with a time complexity of \\(O(1)\\).

    ArrayQueuepush()pop()

    Figure 5-6 \u00a0 Implementing Queue with Array for Enqueue and Dequeue Operations

    You might notice a problem: as enqueue and dequeue operations are continuously performed, both front and rear move to the right and will eventually reach the end of the array and can't move further. To resolve this, we can treat the array as a \"circular array\" where connecting the end of the array back to its beginning.

    In a circular array, front or rear needs to loop back to the start of the array upon reaching the end. This cyclical pattern can be achieved with a \"modulo operation\" as shown in the code below:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_queue.py
    class ArrayQueue:\n    \"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._nums: list[int] = [0] * size  # \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n        self._front: int = 0  # \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n        self._size: int = 0  # \u961f\u5217\u957f\u5ea6\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\n        return len(self._nums)\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"\u961f\u5217\u5df2\u6ee1\")\n        # \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        # \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        rear: int = (self._front + self._size) % self.capacity()\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u961f\"\"\"\n        num: int = self.peek()\n        # \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\n        return self._nums[self._front]\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n
    array_queue.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n  private:\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u961f\u5217\u957f\u5ea6\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n\n  public:\n    ArrayQueue(int capacity) {\n        // \u521d\u59cb\u5316\u6570\u7ec4\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout << \"\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % queCapacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    int pop() {\n        int num = peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        return nums[front];\n    }\n\n    /* \u5c06\u6570\u7ec4\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> arr(queSize);\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n
    array_queue.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private int[] nums; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private int queSize; // \u961f\u5217\u957f\u5ea6\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % capacity();\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int pop() {\n        int num = peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    public int[] toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n
    array_queue.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize; // \u961f\u5217\u957f\u5ea6\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % Capacity();\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int Pop() {\n        int num = Peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n
    array_queue.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntype arrayQueue struct {\n    nums        []int // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    queSize     int   // \u961f\u5217\u957f\u5ea6\n    queCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* \u5165\u961f */\nfunc (q *arrayQueue) push(num int) {\n    // \u5f53 rear == queCapacity \u8868\u793a\u961f\u5217\u5df2\u6ee1\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    rear := (q.front + q.queSize) % q.queCapacity\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* \u51fa\u961f */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear >= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n
    array_queue.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var _size: Int // \u961f\u5217\u957f\u5ea6\n\n    init(capacity: Int) {\n        // \u521d\u59cb\u5316\u6570\u7ec4\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    func capacity() -> Int {\n        nums.count\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        let rear = (front + size()) % capacity()\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* \u51fa\u961f */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return nums[front]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    func toArray() -> [Int] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        (front ..< front + size()).map { nums[$0 % capacity()] }\n    }\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\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        const rear = (this.#front + this.size) % this.capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop() {\n        const num = this.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek() {\n        if (this.isEmpty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.#nums[this.#front];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i < this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n
    array_queue.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private queSize: number; // \u961f\u5217\u957f\u5ea6\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        const rear = (this.front + this.queSize) % this.capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop(): number {\n        const num = this.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.nums[this.front];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray(): number[] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i < this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n
    array_queue.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n  late List<int> _nums; // \u7528\u4e8e\u50a8\u5b58\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n  late int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n  late int _queSize; // \u961f\u5217\u957f\u5ea6\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u5165\u961f */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"\u961f\u5217\u5df2\u6ee1\");\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    int rear = (_front + _queSize) % capaCity();\n    // \u5c06 _num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* \u51fa\u961f */\n  int pop() {\n    int _num = peek();\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"\u961f\u5217\u4e3a\u7a7a\");\n    }\n    return _nums[_front];\n  }\n\n  /* \u8fd4\u56de Array */\n  List<int> toArray() {\n    // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    final List<int> res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i < _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n
    array_queue.rs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nstruct ArrayQueue {\n    nums: Vec<i32>,    // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front: i32,        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    que_size: i32,     // \u961f\u5217\u957f\u5ea6\n    que_capacity: i32, // \u961f\u5217\u5bb9\u91cf\n}\n\nimpl ArrayQueue {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(capacity: i32) -> ArrayQueue {\n        ArrayQueue {\n            nums: vec![0; capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    fn capacity(&self) -> i32 {\n        self.que_capacity\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fn size(&self) -> i32 {\n        self.que_size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fn is_empty(&self) -> bool {\n        self.que_size == 0\n    }\n\n    /* \u5165\u961f */\n    fn push(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* \u51fa\u961f */\n    fn pop(&mut self) -> i32 {\n        let num = self.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fn peek(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    fn to_vector(&self) -> Vec<i32> {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![0; self.que_size as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n
    array_queue.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntypedef struct {\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n} ArrayQueue;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // \u521d\u59cb\u5316\u6570\u7ec4\n    queue->queCapacity = capacity;\n    queue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);\n    queue->front = queue->queSize = 0;\n    return queue;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue->nums);\n    free(queue);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(ArrayQueue *queue) {\n    return queue->queCapacity;\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(ArrayQueue *queue) {\n    return queue->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(ArrayQueue *queue) {\n    return queue->queSize == 0;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue->nums[queue->front];\n}\n\n/* \u5165\u961f */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    int rear = (queue->front + queue->queSize) % queue->queCapacity;\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    queue->nums[rear] = num;\n    queue->queSize++;\n}\n\n/* \u51fa\u961f */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    queue->front = (queue->front + 1) % queue->queCapacity;\n    queue->queSize--;\n    return num;\n}\n
    array_queue.kt
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue(capacity: Int) {\n    private val nums = IntArray(capacity) // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var queSize = 0 // \u961f\u5217\u957f\u5ea6\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* \u5165\u961f */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        val rear = (front + queSize) % capacity()\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        queSize++\n    }\n\n    /* \u51fa\u961f */\n    fun pop(): Int {\n        val num = peek()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    fun toArray(): IntArray {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i < queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n
    array_queue.rb
    [class]{ArrayQueue}-[func]{}\n
    array_queue.zig
    // \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\nfn ArrayQueue(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        nums: []T = undefined,                          // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4     \n        cap: usize = 0,                                 // \u961f\u5217\u5bb9\u91cf\n        front: usize = 0,                               // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n        queSize: usize = 0,                             // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6570\u7ec4\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.cap = cap;\n            self.nums = try self.mem_allocator.alloc(T, self.cap);\n            @memset(self.nums, @as(T, 0));\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\n        pub fn capacity(self: *Self) usize {\n            return self.cap;\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.queSize;\n        }\n\n        // \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.queSize == 0;\n        }\n\n        // \u5165\u961f\n        pub fn push(self: *Self, num: T) !void {\n            if (self.size() == self.capacity()) {\n                std.debug.print(\"\u961f\u5217\u5df2\u6ee1\\n\", .{});\n                return;\n            }\n            // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n            // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n            var rear = (self.front + self.queSize) % self.capacity();\n            // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n            self.nums[rear] = num;\n            self.queSize += 1;\n        } \n\n        // \u51fa\u961f\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n            self.front = (self.front + 1) % self.capacity();\n            self.queSize -= 1;\n            return num;\n        } \n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\n            return self.nums[self.front];\n        } \n\n        // \u8fd4\u56de\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            var j: usize = self.front;\n            while (i < self.size()) : ({ i += 1; j += 1; }) {\n                res[i] = self.nums[j % self.capacity()];\n            }\n            return res;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    The above implementation of the queue still has its limitations: its length is fixed. However, this issue is not difficult to resolve. We can replace the array with a dynamic array that can expand itself if needed. Interested readers can try to implement this themselves.

    The comparison of the two implementations is consistent with that of the stack and is not repeated here.

    "},{"location":"chapter_stack_and_queue/queue/#523-typical-applications-of-queue","title":"5.2.3 \u00a0 Typical Applications of Queue","text":"
    • Amazon Orders. After shoppers place orders, these orders join a queue, and the system processes them in order. During events like Singles' Day, a massive number of orders are generated in a short time, making high concurrency a key challenge for engineers.
    • Various To-Do Lists. Any scenario requiring a \"first-come, first-served\" functionality, such as a printer's task queue or a restaurant's food delivery queue, can effectively maintain the order of processing with a queue.
    "},{"location":"chapter_stack_and_queue/stack/","title":"5.1 \u00a0 Stack","text":"

    A \"Stack\" is a linear data structure that follows the principle of Last-In-First-Out (LIFO).

    We can compare a stack to a pile of plates on a table. To access the bottom plate, one must first remove the plates on top. By replacing the plates with various types of elements (such as integers, characters, objects, etc.), we obtain the data structure known as a stack.

    As shown in the Figure 5-1 , we refer to the top of the pile of elements as the \"top of the stack\" and the bottom as the \"bottom of the stack.\" The operation of adding elements to the top of the stack is called \"push,\" and the operation of removing the top element is called \"pop.\"

    Figure 5-1 \u00a0 Stack's Last-In-First-Out Rule

    "},{"location":"chapter_stack_and_queue/stack/#511-common-operations-on-stack","title":"5.1.1 \u00a0 Common Operations on Stack","text":"

    The common operations on a stack are shown in the Table 5-1 . The specific method names depend on the programming language used. Here, we use push(), pop(), and peek() as examples.

    Table 5-1 \u00a0 Efficiency of Stack Operations

    Method Description Time Complexity push() Push an element onto the stack (add to the top) \\(O(1)\\) pop() Pop the top element from the stack \\(O(1)\\) peek() Access the top element of the stack \\(O(1)\\)

    Typically, we can directly use the stack class built into the programming language. However, some languages may not specifically provide a stack class. In these cases, we can use the language's \"array\" or \"linked list\" as a stack and ignore operations that are not related to stack logic in the program.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig stack.py
    # Initialize the stack\n# Python does not have a built-in stack class, so a list can be used as a stack\nstack: list[int] = []\n\n# Push elements onto the stack\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# Access the top element of the stack\npeek: int = stack[-1]\n\n# Pop an element from the stack\npop: int = stack.pop()\n\n# Get the length of the stack\nsize: int = len(stack)\n\n# Check if the stack is empty\nis_empty: bool = len(stack) == 0\n
    stack.cpp
    /* Initialize the stack */\nstack<int> stack;\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nint top = stack.top();\n\n/* Pop an element from the stack */\nstack.pop(); // No return value\n\n/* Get the length of the stack */\nint size = stack.size();\n\n/* Check if the stack is empty */\nbool empty = stack.empty();\n
    stack.java
    /* Initialize the stack */\nStack<Integer> stack = new Stack<>();\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nint peek = stack.peek();\n\n/* Pop an element from the stack */\nint pop = stack.pop();\n\n/* Get the length of the stack */\nint size = stack.size();\n\n/* Check if the stack is empty */\nboolean isEmpty = stack.isEmpty();\n
    stack.cs
    /* Initialize the stack */\nStack<int> stack = new();\n\n/* Push elements onto the stack */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* Access the top element of the stack */\nint peek = stack.Peek();\n\n/* Pop an element from the stack */\nint pop = stack.Pop();\n\n/* Get the length of the stack */\nint size = stack.Count;\n\n/* Check if the stack is empty */\nbool isEmpty = stack.Count == 0;\n
    stack_test.go
    /* Initialize the stack */\n// In Go, it is recommended to use a Slice as a stack\nvar stack []int\n\n/* Push elements onto the stack */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* Access the top element of the stack */\npeek := stack[len(stack)-1]\n\n/* Pop an element from the stack */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* Get the length of the stack */\nsize := len(stack)\n\n/* Check if the stack is empty */\nisEmpty := len(stack) == 0\n
    stack.swift
    /* Initialize the stack */\n// Swift does not have a built-in stack class, so Array can be used as a stack\nvar stack: [Int] = []\n\n/* Push elements onto the stack */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* Access the top element of the stack */\nlet peek = stack.last!\n\n/* Pop an element from the stack */\nlet pop = stack.removeLast()\n\n/* Get the length of the stack */\nlet size = stack.count\n\n/* Check if the stack is empty */\nlet isEmpty = stack.isEmpty\n
    stack.js
    /* Initialize the stack */\n// JavaScript does not have a built-in stack class, so Array can be used as a stack\nconst stack = [];\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nconst peek = stack[stack.length-1];\n\n/* Pop an element from the stack */\nconst pop = stack.pop();\n\n/* Get the length of the stack */\nconst size = stack.length;\n\n/* Check if the stack is empty */\nconst is_empty = stack.length === 0;\n
    stack.ts
    /* Initialize the stack */\n// TypeScript does not have a built-in stack class, so Array can be used as a stack\nconst stack: number[] = [];\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nconst peek = stack[stack.length - 1];\n\n/* Pop an element from the stack */\nconst pop = stack.pop();\n\n/* Get the length of the stack */\nconst size = stack.length;\n\n/* Check if the stack is empty */\nconst is_empty = stack.length === 0;\n
    stack.dart
    /* Initialize the stack */\n// Dart does not have a built-in stack class, so List can be used as a stack\nList<int> stack = [];\n\n/* Push elements onto the stack */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* Access the top element of the stack */\nint peek = stack.last;\n\n/* Pop an element from the stack */\nint pop = stack.removeLast();\n\n/* Get the length of the stack */\nint size = stack.length;\n\n/* Check if the stack is empty */\nbool isEmpty = stack.isEmpty;\n
    stack.rs
    /* Initialize the stack */\n// Use Vec as a stack\nlet mut stack: Vec<i32> = Vec::new();\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nlet top = stack.last().unwrap();\n\n/* Pop an element from the stack */\nlet pop = stack.pop().unwrap();\n\n/* Get the length of the stack */\nlet size = stack.len();\n\n/* Check if the stack is empty */\nlet is_empty = stack.is_empty();\n
    stack.c
    // C does not provide a built-in stack\n
    stack.kt
    \n
    stack.zig
    \n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/stack/#512-implementing-a-stack","title":"5.1.2 \u00a0 Implementing a Stack","text":"

    To gain a deeper understanding of how a stack operates, let's try implementing a stack class ourselves.

    A stack follows the principle of Last-In-First-Out, which means we can only add or remove elements at the top of the stack. However, both arrays and linked lists allow adding and removing elements at any position, therefore a stack can be seen as a restricted array or linked list. In other words, we can \"shield\" certain irrelevant operations of an array or linked list, aligning their external behavior with the characteristics of a stack.

    "},{"location":"chapter_stack_and_queue/stack/#1-implementation-based-on-linked-list","title":"1. \u00a0 Implementation Based on Linked List","text":"

    When implementing a stack using a linked list, we can consider the head node of the list as the top of the stack and the tail node as the bottom of the stack.

    As shown in the Figure 5-2 , for the push operation, we simply insert elements at the head of the linked list. This method of node insertion is known as \"head insertion.\" For the pop operation, we just need to remove the head node from the list.

    LinkedListStackpush()pop()

    Figure 5-2 \u00a0 Implementing Stack with Linked List for Push and Pop Operations

    Below is an example code for implementing a stack based on a linked list:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_stack.py
    class LinkedListStack:\n    \"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return not self._peek\n\n    def push(self, val: int):\n        \"\"\"\u5165\u6808\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u6808\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._peek.val\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n
    linkedlist_stack.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int stkSize;        // \u6808\u7684\u957f\u5ea6\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    int size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node->next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop->next;\n        // \u91ca\u653e\u5185\u5b58\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"\u6808\u4e3a\u7a7a\");\n        return stackTop->val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        ListNode *node = stackTop;\n        vector<int> res(size());\n        for (int i = res.size() - 1; i >= 0; i--) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_stack.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private ListNode stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private int stkSize = 0; // \u6808\u7684\u957f\u5ea6\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i >= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    ListNode? stackPeek;  // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int stkSize = 0;   // \u6808\u7684\u957f\u5ea6\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i >= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u6808 */\nfunc newLinkedListStack() *linkedListStack {\n    return &linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* \u5165\u6808 */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* \u51fa\u6808 */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n
    linkedlist_stack.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private var _peek: ListNode? // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private var _size: Int // \u6808\u7684\u957f\u5ea6\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u6808 */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* \u51fa\u6808 */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return _peek!.val\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\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\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    peek() {\n        if (!this.#stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stackPeek.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i >= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private stkSize: number = 0; // \u6808\u7684\u957f\u5ea6\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stackPeek.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array<number>(this.size);\n        for (let i = res.length - 1; i >= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.dart
    /* \u57fa\u4e8e\u94fe\u8868\u7c7b\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n  ListNode? _stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n  int _stkSize = 0; // \u6808\u7684\u957f\u5ea6\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n  int size() {\n    return _stkSize;\n  }\n\n  /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* \u5165\u6808 */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* \u51fa\u6808 */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a List \u5e76\u8fd4\u56de */\n  List<int> toList() {\n    ListNode? node = _stackPeek;\n    List<int> list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n
    linkedlist_stack.rs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\n#[allow(dead_code)]\npub struct LinkedListStack<T> {\n    stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    stk_size: usize,                              // \u6808\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListStack<T> {\n    pub fn new() -> Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.stk_size;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    pub fn push(&mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* \u51fa\u6808 */\n    pub fn pop(&mut self) -> Option<T> {\n        self.stack_peek.take().map(|old_head| {\n            match old_head.borrow_mut().next.take() {\n                Some(new_head) => {\n                    self.stack_peek = Some(new_head);\n                }\n                None => {\n                    self.stack_peek = None;\n                }\n            }\n            self.stk_size -= 1;\n            Rc::try_unwrap(old_head).ok().unwrap().into_inner().val\n        })\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.stack_peek.as_ref()\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.push(node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_stack.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\ntypedef struct {\n    ListNode *top; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int size;      // \u6808\u7684\u957f\u5ea6\n} LinkedListStack;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s->top = NULL;\n    s->size = 0;\n    return s;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s->top) {\n        ListNode *n = s->top->next;\n        free(s->top);\n        s->top = n;\n    }\n    free(s);\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(LinkedListStack *s) {\n    return s->size;\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* \u5165\u6808 */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node->next = s->top; // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6307\u9488\u57df\n    node->val = num;     // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6570\u636e\u57df\n    s->top = node;       // \u66f4\u65b0\u6808\u9876\n    s->size++;           // \u66f4\u65b0\u6808\u5927\u5c0f\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(LinkedListStack *s) {\n    if (s->size == 0) {\n        printf(\"\u6808\u4e3a\u7a7a\\n\");\n        return INT_MAX;\n    }\n    return s->top->val;\n}\n\n/* \u51fa\u6808 */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s->top;\n    s->top = s->top->next;\n    // \u91ca\u653e\u5185\u5b58\n    free(tmp);\n    s->size--;\n    return val;\n}\n
    linkedlist_stack.kt
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private var stkSize: Int = 0 // \u6808\u7684\u957f\u5ea6\n) {\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* \u51fa\u6808 */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--;\n        return num\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?.value\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?.value!!\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_stack.rb
    [class]{LinkedListStack}-[func]{}\n
    linkedlist_stack.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\nfn LinkedListStack(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        stack_top: ?*inc.ListNode(T) = null,             // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n        stk_size: usize = 0,                             // \u6808\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,    // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.stack_top = null;\n            self.stk_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u6808\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.stk_size;\n        }\n\n        // \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u6808\u9876\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.size() == 0) @panic(\"\u6808\u4e3a\u7a7a\");\n            return self.stack_top.?.val;\n        }  \n\n        // \u5165\u6808\n        pub fn push(self: *Self, num: T) !void {\n            var node = try self.mem_allocator.create(inc.ListNode(T));\n            node.init(num);\n            node.next = self.stack_top;\n            self.stack_top = node;\n            self.stk_size += 1;\n        } \n\n        // \u51fa\u6808\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            self.stack_top = self.stack_top.?.next;\n            self.stk_size -= 1;\n            return num;\n        } \n\n        // \u5c06\u6808\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.stack_top;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[res.len - i - 1] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/stack/#2-implementation-based-on-array","title":"2. \u00a0 Implementation Based on Array","text":"

    When implementing a stack using an array, we can consider the end of the array as the top of the stack. As shown in the Figure 5-3 , push and pop operations correspond to adding and removing elements at the end of the array, respectively, both with a time complexity of \\(O(1)\\).

    ArrayStackpush()pop()

    Figure 5-3 \u00a0 Implementing Stack with Array for Push and Pop Operations

    Since the elements to be pushed onto the stack may continuously increase, we can use a dynamic array, thus avoiding the need to handle array expansion ourselves. Here is an example code:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_stack.py
    class ArrayStack:\n    \"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._stack == []\n\n    def push(self, item: int):\n        \"\"\"\u5165\u6808\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u6808\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._stack.pop()\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._stack[-1]\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        return self._stack\n
    array_stack.cpp
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n  private:\n    vector<int> stack;\n\n  public:\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    int size() {\n        return stack.size();\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* \u51fa\u6808 */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"\u6808\u4e3a\u7a7a\");\n        return stack.back();\n    }\n\n    /* \u8fd4\u56de Vector */\n    vector<int> toVector() {\n        return stack;\n    }\n};\n
    array_stack.java
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private ArrayList<Integer> stack;\n\n    public ArrayStack() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = new ArrayList<>();\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int size() {\n        return stack.size();\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* \u51fa\u6808 */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n
    array_stack.cs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    List<int> stack;\n    public ArrayStack() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* \u51fa\u6808 */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n
    array_stack.go
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntype arrayStack struct {\n    data []int // \u6570\u636e\n}\n\n/* \u521d\u59cb\u5316\u6808 */\nfunc newArrayStack() *arrayStack {\n    return &arrayStack{\n        // \u8bbe\u7f6e\u6808\u7684\u957f\u5ea6\u4e3a 0\uff0c\u5bb9\u91cf\u4e3a 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* \u6808\u7684\u957f\u5ea6 */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* \u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* \u5165\u6808 */\nfunc (s *arrayStack) push(v int) {\n    // \u5207\u7247\u4f1a\u81ea\u52a8\u6269\u5bb9\n    s.data = append(s.data, v)\n}\n\n/* \u51fa\u6808 */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* \u83b7\u53d6\u6808\u9876\u5143\u7d20 */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n
    array_stack.swift
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = []\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        stack.count\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        stack.isEmpty\n    }\n\n    /* \u5165\u6808 */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* \u51fa\u6808 */\n    @discardableResult\n    func pop() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return stack.removeLast()\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return stack.last!\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        stack\n    }\n}\n
    array_stack.js
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    pop() {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stack.pop();\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    top() {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n
    array_stack.ts
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stack.pop();\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        return this.stack;\n    }\n}\n
    array_stack.dart
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n  late List<int> _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n  int size() {\n    return _stack.length;\n  }\n\n  /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* \u5165\u6808 */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* \u51fa\u6808 */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stack.last;\n  }\n\n  /* \u5c06\u6808\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n  List<int> toArray() => _stack;\n}\n
    array_stack.rs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nstruct ArrayStack<T> {\n    stack: Vec<T>,\n}\n\nimpl<T> ArrayStack<T> {\n    /* \u521d\u59cb\u5316\u6808 */\n    fn new() -> ArrayStack<T> {\n        ArrayStack::<T> {\n            stack: Vec::<T>::new(),\n        }\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fn size(&self) -> usize {\n        self.stack.len()\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fn is_empty(&self) -> bool {\n        self.size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fn push(&mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    fn pop(&mut self) -> Option<T> {\n        self.stack.pop()\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fn peek(&self) -> Option<&T> {\n        if self.is_empty() {\n            panic!(\"\u6808\u4e3a\u7a7a\")\n        };\n        self.stack.last()\n    }\n\n    /* \u8fd4\u56de &Vec */\n    fn to_array(&self) -> &Vec<T> {\n        &self.stack\n    }\n}\n
    array_stack.c
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5927\u5bb9\u91cf\uff0c\u907f\u514d\u6269\u5bb9\n    stack->data = malloc(sizeof(int) * MAX_SIZE);\n    stack->size = 0;\n    return stack;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack->data);\n    free(stack);\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(ArrayStack *stack) {\n    return stack->size;\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(ArrayStack *stack) {\n    return stack->size == 0;\n}\n\n/* \u5165\u6808 */\nvoid push(ArrayStack *stack, int num) {\n    if (stack->size == MAX_SIZE) {\n        printf(\"\u6808\u5df2\u6ee1\\n\");\n        return;\n    }\n    stack->data[stack->size] = num;\n    stack->size++;\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(ArrayStack *stack) {\n    if (stack->size == 0) {\n        printf(\"\u6808\u4e3a\u7a7a\\n\");\n        return INT_MAX;\n    }\n    return stack->data[stack->size - 1];\n}\n\n/* \u51fa\u6808 */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack->size--;\n    return val;\n}\n
    array_stack.kt
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n    private val stack = ArrayList<Int>()\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* \u51fa\u6808 */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): Array<Any> {\n        return stack.toArray()\n    }\n}\n
    array_stack.rb
    [class]{ArrayStack}-[func]{}\n
    array_stack.zig
    // \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\nfn ArrayStack(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        stack: ?std.ArrayList(T) = null,     \n\n        // \u6784\u9020\u65b9\u6cd5\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) void {\n            if (self.stack == null) {\n                self.stack = std.ArrayList(T).init(allocator);\n            }\n        }\n\n        // \u6790\u6784\u65b9\u6cd5\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.stack == null) return;\n            self.stack.?.deinit();\n        }\n\n        // \u83b7\u53d6\u6808\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.stack.?.items.len;\n        }\n\n        // \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u6808\u9876\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u6808\u4e3a\u7a7a\");\n            return self.stack.?.items[self.size() - 1];\n        }  \n\n        // \u5165\u6808\n        pub fn push(self: *Self, num: T) !void {\n            try self.stack.?.append(num);\n        } \n\n        // \u51fa\u6808\n        pub fn pop(self: *Self) T {\n            var num = self.stack.?.pop();\n            return num;\n        } \n\n        // \u8fd4\u56de ArrayList\n        pub fn toList(self: *Self) std.ArrayList(T) {\n            return self.stack.?;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/stack/#513-comparison-of-the-two-implementations","title":"5.1.3 \u00a0 Comparison of the Two Implementations","text":"

    Supported Operations

    Both implementations support all the operations defined in a stack. The array implementation additionally supports random access, but this is beyond the scope of a stack definition and is generally not used.

    Time Efficiency

    In the array-based implementation, both push and pop operations occur in pre-allocated contiguous memory, which has good cache locality and therefore higher efficiency. However, if the push operation exceeds the array capacity, it triggers a resizing mechanism, making the time complexity of that push operation \\(O(n)\\).

    In the linked list implementation, list expansion is very flexible, and there is no efficiency decrease issue as in array expansion. However, the push operation requires initializing a node object and modifying pointers, so its efficiency is relatively lower. If the elements being pushed are already node objects, then the initialization step can be skipped, improving efficiency.

    Thus, when the elements for push and pop operations are basic data types like int or double, we can draw the following conclusions:

    • The array-based stack implementation's efficiency decreases during expansion, but since expansion is a low-frequency operation, its average efficiency is higher.
    • The linked list-based stack implementation provides more stable efficiency performance.

    Space Efficiency

    When initializing a list, the system allocates an \"initial capacity,\" which might exceed the actual need; moreover, the expansion mechanism usually increases capacity by a specific factor (like doubling), which may also exceed the actual need. Therefore, the array-based stack might waste some space.

    However, since linked list nodes require extra space for storing pointers, the space occupied by linked list nodes is relatively larger.

    In summary, we cannot simply determine which implementation is more memory-efficient. It requires analysis based on specific circumstances.

    "},{"location":"chapter_stack_and_queue/stack/#514-typical-applications-of-stack","title":"5.1.4 \u00a0 Typical Applications of Stack","text":"
    • Back and forward in browsers, undo and redo in software. Every time we open a new webpage, the browser pushes the previous page onto the stack, allowing us to go back to the previous page through the back operation, which is essentially a pop operation. To support both back and forward, two stacks are needed to work together.
    • Memory management in programs. Each time a function is called, the system adds a stack frame at the top of the stack to record the function's context information. In recursive functions, the downward recursion phase keeps pushing onto the stack, while the upward backtracking phase keeps popping from the stack.
    "},{"location":"chapter_stack_and_queue/summary/","title":"5.4 \u00a0 Summary","text":""},{"location":"chapter_stack_and_queue/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"
    • Stack is a data structure that follows the Last-In-First-Out (LIFO) principle and can be implemented using arrays or linked lists.
    • In terms of time efficiency, the array implementation of the stack has a higher average efficiency. However, during expansion, the time complexity for a single push operation can degrade to \\(O(n)\\). In contrast, the linked list implementation of a stack offers more stable efficiency.
    • Regarding space efficiency, the array implementation of the stack may lead to a certain degree of space wastage. However, it's important to note that the memory space occupied by nodes in a linked list is generally larger than that for elements in an array.
    • A queue is a data structure that follows the First-In-First-Out (FIFO) principle, and it can also be implemented using arrays or linked lists. The conclusions regarding time and space efficiency for queues are similar to those for stacks.
    • A double-ended queue (deque) is a more flexible type of queue that allows adding and removing elements at both ends.
    "},{"location":"chapter_stack_and_queue/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Is the browser's forward and backward functionality implemented with a doubly linked list?

    A browser's forward and backward navigation is essentially a manifestation of the \"stack\" concept. When a user visits a new page, the page is added to the top of the stack; when they click the back button, the page is popped from the top of the stack. A double-ended queue (deque) can conveniently implement some additional operations, as mentioned in the \"Double-Ended Queue\" section.

    Q: After popping from a stack, is it necessary to free the memory of the popped node?

    If the popped node will still be used later, it's not necessary to free its memory. In languages like Java and Python that have automatic garbage collection, manual memory release is not necessary; in C and C++, manual memory release is required.

    Q: A double-ended queue seems like two stacks joined together. What are its uses?

    A double-ended queue, which is a combination of a stack and a queue or two stacks joined together, exhibits both stack and queue logic. Thus, it can implement all applications of stacks and queues while offering more flexibility.

    Q: How exactly are undo and redo implemented?

    Undo and redo operations are implemented using two stacks: Stack A for undo and Stack B for redo.

    1. Each time a user performs an operation, it is pushed onto Stack A, and Stack B is cleared.
    2. When the user executes an \"undo\", the most recent operation is popped from Stack A and pushed onto Stack B.
    3. When the user executes a \"redo\", the most recent operation is popped from Stack B and pushed back onto Stack A.
    "}]} \ No newline at end of file +{"config":{"lang":["en"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"]},"docs":[{"location":"","title":"Home","text":"Hello Algo

    Data Structures and Algorithms Crash Course with Animated Illustrations and Off-the-Shelf Code

    Dive In Clone Repo Get PDF

    The English edition is brewing...

    Feel free to engage in Chinese-to-English translation and pull request review! For guidelines, please see #914.

    Quote

    \"An easy-to-understand book on data structures and algorithms, which guides readers to learn by minds-on and hands-on. Strongly recommended for algorithm beginners!\"

    \u2014\u2014 Junhui Deng, Professor of Computer Science, Tsinghua University

    Quote

    \"If I had 'Hello Algo' when I was learning data structures and algorithms, it would have been 10 times easier!\"

    \u2014\u2014 Mu Li, Senior Principal Scientist, Amazon

    Animated illustrations

    Easy to understandSmooth learning curve

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

    Off-the-Shelf Code

    Multi programming languagesRun with one click

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

    Learning Together

    Discussion and questions welcomeReaders progress together

    \"Learning by teaching.\"

    Preface

    Two years ago, I shared the \"Sword Offer\" series of problem solutions on LeetCode, which received much love and support from many students. During my interactions with readers, the most common question I encountered was \"How to get started with algorithms.\" Gradually, I developed a deep interest in this question.

    Blindly solving problems seems to be the most popular method, being simple, direct, and effective. However, problem-solving is like playing a \"Minesweeper\" game, where students with strong self-learning abilities can successfully clear the mines one by one, but those with insufficient foundations may end up bruised from explosions, retreating step by step in frustration. Thoroughly reading textbooks is also common, but for students aiming for job applications, the energy consumed by graduation, resume submissions, and preparing for written tests and interviews makes tackling thick books a daunting challenge.

    If you are facing similar troubles, then you are lucky to have found this book. This book is my answer to this question, not necessarily the best solution, but at least an active attempt. Although this book won't directly land you an Offer, it will guide you through the \"knowledge map\" of data structures and algorithms, help you understand the shape, size, and distribution of different \"mines,\" and equip you with various \"demining methods.\" With these skills, I believe you can more comfortably solve problems and read literature, gradually building a complete knowledge system.

    I deeply agree with Professor Feynman's saying: \"Knowledge isn't free. You have to pay attention.\" In this sense, this book is not entirely \"free.\" To not disappoint the precious \"attention\" you pay to this book, I will do my utmost, investing the greatest \"attention\" to complete the creation of this book.

    Author

    Yudong Jin(krahets), Senior Algorithm Engineer in a top tech company, Master's degree from Shanghai Jiao Tong University. The highest-read blogger across the entire LeetCode, his published \"Illustration of Algorithm Data Structures\" has been subscribed to by over 300k.

    Contribution

    This book is continuously improved with the joint efforts of many contributors from the open-source community. Thanks to each writer who invested their time and energy, listed in the order generated by GitHub:

    The code review work for this book was completed by codingonion, Gonglja, gvenusleo, hpstory, justin\u2010tse, krahets, night-cruise, nuomi1, and Reanon (listed in alphabetical order). Thanks to them for their time and effort, ensuring the standardization and uniformity of the code in various languages.

    codingonionRust, Zig GongljaC, C++ gvenusleoDart hpstoryC# justin-tseJS, TS krahetsJava, Python night-cruiseRust nuomi1Swift ReanonGo, C"},{"location":"chapter_array_and_linkedlist/","title":"Chapter 4. \u00a0 Arrays and Linked Lists","text":"

    Abstract

    The world of data structures resembles a sturdy brick wall.

    In arrays, envision bricks snugly aligned, each resting seamlessly beside the next, creating a unified formation. Meanwhile, in linked lists, these bricks disperse freely, embraced by vines gracefully knitting connections between them.

    "},{"location":"chapter_array_and_linkedlist/#chapter-contents","title":"Chapter Contents","text":"
    • 4.1 \u00a0 Array
    • 4.2 \u00a0 Linked List
    • 4.3 \u00a0 List
    • 4.4 \u00a0 Memory and Cache
    • 4.5 \u00a0 Summary
    "},{"location":"chapter_array_and_linkedlist/array/","title":"4.1 \u00a0 Arrays","text":"

    An \"array\" is a linear data structure that operates as a lineup of similar items, stored together in a computer's memory in contiguous spaces. It's like a sequence that maintains organized storage. Each item in this lineup has its unique 'spot' known as an \"index\". Please refer to the Figure 4-1 to observe how arrays work and grasp these key terms.

    Figure 4-1 \u00a0 Array Definition and Storage Method

    "},{"location":"chapter_array_and_linkedlist/array/#411-common-operations-on-arrays","title":"4.1.1 \u00a0 Common Operations on Arrays","text":""},{"location":"chapter_array_and_linkedlist/array/#1-initializing-arrays","title":"1. \u00a0 Initializing Arrays","text":"

    Arrays can be initialized in two ways depending on the needs: either without initial values or with specified initial values. When initial values are not specified, most programming languages will set the array elements to \\(0\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig array.py
    # Initialize array\narr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]\nnums: list[int] = [1, 3, 2, 5, 4]\n
    array.cpp
    /* Initialize array */\n// Stored on stack\nint arr[5];\nint nums[5] = { 1, 3, 2, 5, 4 };\n// Stored on heap (manual memory release needed)\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n
    array.java
    /* Initialize array */\nint[] arr = new int[5]; // { 0, 0, 0, 0, 0 }\nint[] nums = { 1, 3, 2, 5, 4 };\n
    array.cs
    /* Initialize array */\nint[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]\nint[] nums = [1, 3, 2, 5, 4];\n
    array.go
    /* Initialize array */\nvar arr [5]int\n// In Go, specifying the length ([5]int) denotes an array, while not specifying it ([]int) denotes a slice.\n// Since Go's arrays are designed to have compile-time fixed length, only constants can be used to specify the length.\n// For convenience in implementing the extend() method, the Slice will be considered as an Array here.\nnums := []int{1, 3, 2, 5, 4}\n
    array.swift
    /* Initialize array */\nlet arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]\nlet nums = [1, 3, 2, 5, 4]\n
    array.js
    /* Initialize array */\nvar arr = new Array(5).fill(0);\nvar nums = [1, 3, 2, 5, 4];\n
    array.ts
    /* Initialize array */\nlet arr: number[] = new Array(5).fill(0);\nlet nums: number[] = [1, 3, 2, 5, 4];\n
    array.dart
    /* Initialize array */\nList<int> arr = List.filled(5, 0); // [0, 0, 0, 0, 0]\nList<int> nums = [1, 3, 2, 5, 4];\n
    array.rs
    /* Initialize array */\nlet arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]\nlet nums: Vec<i32> = vec![1, 3, 2, 5, 4];\n
    array.c
    /* Initialize array */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n
    array.kt
    \n
    array.zig
    // Initialize array\nvar arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }\nvar nums = [_]i32{ 1, 3, 2, 5, 4 };\n
    "},{"location":"chapter_array_and_linkedlist/array/#2-accessing-elements","title":"2. \u00a0 Accessing Elements","text":"

    Elements in an array are stored in contiguous memory spaces, making it simpler to compute each element's memory address. The formula shown in the Figure below aids in determining an element's memory address, utilizing the array's memory address (specifically, the first element's address) and the element's index. This computation streamlines direct access to the desired element.

    Figure 4-2 \u00a0 Memory Address Calculation for Array Elements

    As observed in the above illustration, array indexing conventionally begins at \\(0\\). While this might appear counterintuitive, considering counting usually starts at \\(1\\), within the address calculation formula, an index is essentially an offset from the memory address. For the first element's address, this offset is \\(0\\), validating its index as \\(0\\).

    Accessing elements in an array is highly efficient, allowing us to randomly access any element in \\(O(1)\\) time.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    random_index = random.randint(0, len(nums) - 1)\n    # \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    random_num = nums[random_index]\n    return random_num\n
    array.cpp
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n    // \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = rand() % size;\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.java
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int[] nums) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.cs
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // \u5728\u533a\u95f4 [0, nums.Length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = random.Next(nums.Length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.go
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunc randomAccess(nums []int) (randomNum int) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    randomIndex := rand.Intn(len(nums))\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    randomNum = nums[randomIndex]\n    return\n}\n
    array.swift
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunc randomAccess(nums: [Int]) -> Int {\n    // \u5728\u533a\u95f4 [0, nums.count) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    let randomIndex = nums.indices.randomElement()!\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n
    array.js
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunction randomAccess(nums) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    const random_index = Math.floor(Math.random() * nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    const random_num = nums[random_index];\n    return random_num;\n}\n
    array.ts
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunction randomAccess(nums: number[]): number {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    const random_index = Math.floor(Math.random() * nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    const random_num = nums[random_index];\n    return random_num;\n}\n
    array.dart
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(List<int> nums) {\n  // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n  int randomIndex = Random().nextInt(nums.length);\n  // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n
    array.rs
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfn random_access(nums: &[i32]) -> i32 {\n    // \u5728\u533a\u95f4 [0, nums.len()) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    let random_num = nums[random_index];\n    random_num\n}\n
    array.c
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n    // \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = rand() % size;\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.kt
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfun randomAccess(nums: IntArray): Int {\n    // \u5728\u533a\u95f4 [0, nums.size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n
    array.rb
    ### \u968f\u673a\u8bbf\u95ee\u5143\u7d20 ###\ndef random_access(nums)\n  # \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n  random_index = Random.rand 0...(nums.length - 1)\n\n  # \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n  nums[random_index]\nend\n
    array.zig
    // \u968f\u673a\u8bbf\u95ee\u5143\u7d20\nfn randomAccess(nums: []i32) i32 {\n    // \u5728\u533a\u95f4 [0, nums.len) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6574\u6570\n    var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    var randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#3-inserting-elements","title":"3. \u00a0 Inserting Elements","text":"

    Array elements are tightly packed in memory, with no space available to accommodate additional data between them. Illustrated in Figure below, inserting an element in the middle of an array requires shifting all subsequent elements back by one position to create room for the new element.

    Figure 4-3 \u00a0 Array Element Insertion Example

    It's important to note that due to the fixed length of an array, inserting an element will unavoidably result in the loss of the last element in the array. Solutions to address this issue will be explored in the \"List\" chapter.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def insert(nums: list[int], num: int, index: int):\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\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num\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\n    for (int i = size - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    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\n    for (int i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (int i = nums.Length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\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\n    for i := len(nums) - 1; i > index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (let i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (let i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 _num */\nvoid insert(List<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\n  for (var i = nums.length - 1; i > index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // \u5c06 _num \u8d4b\u7ed9 index \u5904\u5143\u7d20\n  nums[index] = _num;\n}\n
    array.rs
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfn insert(nums: &mut Vec<i32>, num: i32, index: usize) {\n    // \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (int i = size - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    array.kt
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num\n}\n
    array.rb
    ### \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num ###\ndef insert(nums, num, index)\n  # \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n  nums[index] = num\nend\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\n    var i = nums.len - 1;\n    while (i > index) : (i -= 1) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#4-deleting-elements","title":"4. \u00a0 Deleting Elements","text":"

    Similarly, as depicted in the Figure 4-4 , to delete an element at index \\(i\\), all elements following index \\(i\\) must be moved forward by one position.

    Figure 4-4 \u00a0 Array Element Deletion Example

    Please note that after deletion, the former last element becomes \"meaningless,\" hence requiring no specific modification.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def remove(nums: list[int], index: int):\n    \"\"\"\u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20\"\"\"\n    # \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n
    array.cpp
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.java
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.cs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.go
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for i := index; i < len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n
    array.swift
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfunc remove(nums: inout [Int], index: Int) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n
    array.js
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfunction remove(nums, index) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (let i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.ts
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (let i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.dart
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nvoid remove(List<int> nums, int index) {\n  // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n  for (var i = index; i < nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n
    array.rs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfn remove(nums: &mut Vec<i32>, index: usize) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.c
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.kt
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfun remove(nums: IntArray, index: Int) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (i in index..<nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n
    array.rb
    ### \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 ###\ndef remove(nums, index)\n  # \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n  for i in index...nums.length\n    nums[i] = nums[i + 1] || 0\n  end\nend\n
    array.zig
    // \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    var i = index;\n    while (i < nums.len - 1) : (i += 1) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    Code Visualization

    Full Screen >

    In summary, the insertion and deletion operations in arrays present the following disadvantages:

    • High Time Complexity: Both insertion and deletion in an array have an average time complexity of \\(O(n)\\), where \\(n\\) is the length of the array.
    • Loss of Elements: Due to the fixed length of arrays, elements that exceed the array's capacity are lost during insertion.
    • Waste of Memory: Initializing a longer array and utilizing only the front part results in \"meaningless\" end elements during insertion, leading to some wasted memory space.
    "},{"location":"chapter_array_and_linkedlist/array/#5-traversing-arrays","title":"5. \u00a0 Traversing Arrays","text":"

    In most programming languages, we can traverse an array either by using indices or by directly iterating over each element:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def traverse(nums: list[int]):\n    \"\"\"\u904d\u5386\u6570\u7ec4\"\"\"\n    count = 0\n    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in range(len(nums)):\n        count += nums[i]\n    # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums:\n        count += num\n    # \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n
    array.cpp
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        count += nums[i];\n    }\n}\n
    array.java
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (int num : nums) {\n        count += num;\n    }\n}\n
    array.cs
    /* \u904d\u5386\u6570\u7ec4 */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < nums.Length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n
    array.go
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums []int) {\n    count := 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i := 0; i < len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for _, num := range nums {\n        count += num\n    }\n    // \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n
    array.swift
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums {\n        count += num\n    }\n    // \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n
    array.js
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums) {\n    let count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (let i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (const num of nums) {\n        count += num;\n    }\n}\n
    array.ts
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (let i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (const num of nums) {\n        count += num;\n    }\n}\n
    array.dart
    /* \u904d\u5386\u6570\u7ec4\u5143\u7d20 */\nvoid traverse(List<int> nums) {\n  int count = 0;\n  // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n  for (var i = 0; i < nums.length; i++) {\n    count += nums[i];\n  }\n  // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n  for (int _num in nums) {\n    count += _num;\n  }\n  // \u901a\u8fc7 forEach \u65b9\u6cd5\u904d\u5386\u6570\u7ec4\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n
    array.rs
    /* \u904d\u5386\u6570\u7ec4 */\nfn traverse(nums: &[i32]) {\n    let mut _count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums {\n        _count += num;\n    }\n}\n
    array.c
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        count += nums[i];\n    }\n}\n
    array.kt
    /* \u904d\u5386\u6570\u7ec4 */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (j: Int in nums) {\n        count += j\n    }\n}\n
    array.rb
    ### \u904d\u5386\u6570\u7ec4 ###\ndef traverse(nums)\n  count = 0\n\n  # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n  for num in nums\n    count += num\n  end\nend\n
    array.zig
    // \u904d\u5386\u6570\u7ec4\nfn traverse(nums: []i32) void {\n    var count: i32 = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    var i: i32 = 0;\n    while (i < nums.len) : (i += 1) {\n        count += nums[i];\n    }\n    count = 0;\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (nums) |num| {\n        count += num;\n    }\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#6-finding-elements","title":"6. \u00a0 Finding Elements","text":"

    Locating a specific element within an array involves iterating through the array, checking each element to determine if it matches the desired value.

    Because arrays are linear data structures, this operation is commonly referred to as \"linear search.\"

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def find(nums: list[int], target: int) -> int:\n    \"\"\"\u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n
    array.cpp
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i < size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.java
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int[] nums, int target) {\n    for (int i = 0; i < nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.cs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint Find(int[] nums, int target) {\n    for (int i = 0; i < nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.go
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i < len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n
    array.swift
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums: [Int], target: Int) -> Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n
    array.js
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums, target) {\n    for (let i = 0; i < nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n
    array.ts
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i < nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(List<int> nums, int target) {\n  for (var i = 0; i < nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n
    array.rs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfn find(nums: &[i32], target: i32) -> Option<usize> {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n
    array.c
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i < size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.kt
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target) return i\n    }\n    return -1\n}\n
    array.rb
    ### \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n
    array.zig
    // \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\nfn find(nums: []i32, target: i32) i32 {\n    for (nums, 0..) |num, i| {\n        if (num == target) return @intCast(i);\n    }\n    return -1;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#7-expanding-arrays","title":"7. \u00a0 Expanding Arrays","text":"

    In complex system environments, ensuring the availability of memory space after an array for safe capacity extension becomes challenging. Consequently, in most programming languages, the length of an array is immutable.

    To expand an array, it's necessary to create a larger array and then copy the elements from the original array. This operation has a time complexity of \\(O(n)\\) and can be time-consuming for large arrays. The code are as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    res = [0] * (len(nums) + enlarge)\n    # \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res\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\n    int *res = new int[size + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        res[i] = nums[i];\n    }\n    // \u91ca\u653e\u5185\u5b58\n    delete[] nums;\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    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\n    int[] res = new int[nums.length + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\n    int[] res = new int[nums.Length + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\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\n    res := make([]int, len(nums)+enlarge)\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for i, num := range nums {\n        res[i] = num\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\n    var 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\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\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\n    const 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\n    for (let i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\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\n    const 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\n    for (let i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    array.dart
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nList<int> extend(List<int> nums, int enlarge) {\n  // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n  List<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\n  for (var i = 0; i < nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n  return res;\n}\n
    array.rs
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfn extend(nums: Vec<i32>, enlarge: usize) -> Vec<i32> {\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n    let mut res: Vec<i32> = vec![0; nums.len() + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\n    for i in 0..nums.len() {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    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\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        res[i] = nums[i];\n    }\n    // \u521d\u59cb\u5316\u6269\u5c55\u540e\u7684\u7a7a\u95f4\n    for (int i = size; i < size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    array.kt
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n    val res = IntArray(nums.size + enlarge)\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res\n}\n
    array.rb
    ### \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 ###\n# \u8bf7\u6ce8\u610f\uff0cRuby \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\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6570\u7ec4\ndef extend(nums, enlarge)\n  # \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n  res = Array.new(nums.length + enlarge, 0)\n\n  # \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n  res\nend\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\n    var 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\n    std.mem.copy(i32, res, nums);\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/array/#412-advantages-and-limitations-of-arrays","title":"4.1.2 \u00a0 Advantages and Limitations of Arrays","text":"

    Arrays are stored in contiguous memory spaces and consist of elements of the same type. This approach provides substantial prior information that systems can leverage to optimize the efficiency of data structure operations.

    • High Space Efficiency: Arrays allocate a contiguous block of memory for data, eliminating the need for additional structural overhead.
    • Support for Random Access: Arrays allow \\(O(1)\\) time access to any element.
    • Cache Locality: When accessing array elements, the computer not only loads them but also caches the surrounding data, utilizing high-speed cache to enchance subsequent operation speeds.

    However, continuous space storage is a double-edged sword, with the following limitations:

    • Low Efficiency in Insertion and Deletion: As arrays accumulate many elements, inserting or deleting elements requires shifting a large number of elements.
    • Fixed Length: The length of an array is fixed after initialization. Expanding an array requires copying all data to a new array, incurring significant costs.
    • Space Wastage: If the allocated array size exceeds the what is necessary, the extra space is wasted.
    "},{"location":"chapter_array_and_linkedlist/array/#413-typical-applications-of-arrays","title":"4.1.3 \u00a0 Typical Applications of Arrays","text":"

    Arrays are fundamental and widely used data structures. They find frequent application in various algorithms and serve in the implementation of complex data structures.

    • Random Access: Arrays are ideal for storing data when random sampling is required. By generating a random sequence based on indices, we can achieve random sampling efficiently.
    • Sorting and Searching: Arrays are the most commonly used data structure for sorting and searching algorithms. Techniques like quick sort, merge sort, binary search, etc., are primarily operate on arrays.
    • Lookup Tables: Arrays serve as efficient lookup tables for quick element or relationship retrieval. For instance, mapping characters to ASCII codes becomes seamless by using the ASCII code values as indices and storing corresponding elements in the array.
    • Machine Learning: Within the domain of neural networks, arrays play a pivotal role in executing crucial linear algebra operations involving vectors, matrices, and tensors. Arrays serve as the primary and most extensively used data structure in neural network programming.
    • Data Structure Implementation: Arrays serve as the building blocks for implementing various data structures like stacks, queues, hash tables, heaps, graphs, etc. For instance, the adjacency matrix representation of a graph is essentially a two-dimensional array.
    "},{"location":"chapter_array_and_linkedlist/linked_list/","title":"4.2 \u00a0 Linked Lists","text":"

    Memory space is a shared resource among all programs. In a complex system environment, available memory can be dispersed throughout the memory space. We understand that the memory allocated for an array must be continuous. However, for very large arrays, finding a sufficiently large contiguous memory space might be challenging. This is where the flexible advantage of linked lists becomes evident.

    A \"linked list\" is a linear data structure in which each element is a node object, and the nodes are interconnected through \"references\". These references hold the memory addresses of subsequent nodes, enabling navigation from one node to the next.

    The design of linked lists allows for their nodes to be distributed across memory locations without requiring contiguous memory addresses.

    Figure 4-5 \u00a0 Linked List Definition and Storage Method

    As shown in the figure, we see that the basic building block of a linked list is the \"node\" object. Each node comprises two key components: the node's \"value\" and a \"reference\" to the next node.

    • The first node in a linked list is the \"head node\", and the final one is the \"tail node\".
    • The tail node points to \"null\", designated as null in Java, nullptr in C++, and None in Python.
    • In languages that support pointers, like C, C++, Go, and Rust, this \"reference\" is typically implemented as a \"pointer\".

    As the code below illustrates, a ListNode in a linked list, besides holding a value, must also maintain an additional reference (or pointer). Therefore, a linked list occupies more memory space than an array when storing the same quantity of data..

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    class ListNode:\n    \"\"\"Linked List Node Class\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # Node value\n        self.next: ListNode | None = None # Reference to the next node\n
    /* Linked List Node Structure */\nstruct ListNode {\n    int val;         // Node value\n    ListNode *next;  // Pointer to the next node\n    ListNode(int x) : val(x), next(nullptr) {}  // Constructor\n};\n
    /* Linked List Node Class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the next node\n    ListNode(int x) { val = x; }  // Constructor\n}\n
    /* Linked List Node Class */\nclass ListNode(int x) {  // Constructor\n    int val = x;         // Node value\n    ListNode? next;      // Reference to the next node\n}\n
    /* Linked List Node Structure */\ntype ListNode struct {\n    Val  int       // Node value\n    Next *ListNode // Pointer to the next node\n}\n\n// NewListNode Constructor, creates a new linked list\nfunc NewListNode(val int) *ListNode {\n    return &ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n
    /* Linked List Node Class */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Reference to the next node\n\n    init(x: Int) { // Constructor\n        val = x\n    }\n}\n
    /* Linked List Node Class */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // Node value\n        this.next = (next === undefined ? null : next); // Reference to the next node\n    }\n}\n
    /* Linked List Node Class */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // Node value\n        this.next = next === undefined ? null : next;  // Reference to the next node\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n  int val; // Node value\n  ListNode? next; // Reference to the next node\n  ListNode(this.val, [this.next]); // Constructor\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n/* Linked List Node Class */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Node value\n    next: Option<Rc<RefCell<ListNode>>>, // Pointer to the next node\n}\n
    /* Linked List Node Structure */\ntypedef struct ListNode {\n    int val;               // Node value\n    struct ListNode *next; // Pointer to the next node\n} ListNode;\n\n/* Constructor */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node->val = val;\n    node->next = NULL;\n    return node;\n}\n
    \n
    // Linked List Node Class\npub fn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = 0, // Node value\n        next: ?*Self = null, // Pointer to the next node\n\n        // Constructor\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n        }\n    };\n}\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#421-common-operations-on-linked-lists","title":"4.2.1 \u00a0 Common Operations on Linked Lists","text":""},{"location":"chapter_array_and_linkedlist/linked_list/#1-initializing-a-linked-list","title":"1. \u00a0 Initializing a Linked List","text":"

    Constructing a linked list is a two-step process: first, initializing each node object, and second, forming the reference links between the nodes. After initialization, we can traverse all nodes sequentially from the head node by following the next reference.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig linked_list.py
    # Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4\n# Initialize each node\nn0 = ListNode(1)\nn1 = ListNode(3)\nn2 = ListNode(2)\nn3 = ListNode(5)\nn4 = ListNode(4)\n# Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n
    linked_list.cpp
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.java
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.cs
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nListNode n0 = new(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.go
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nn0 := NewListNode(1)\nn1 := NewListNode(3)\nn2 := NewListNode(2)\nn3 := NewListNode(5)\nn4 := NewListNode(4)\n// Build references between nodes\nn0.Next = n1\nn1.Next = n2\nn2.Next = n3\nn3.Next = n4\n
    linked_list.swift
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0.next = n1\nn1.next = n2\nn2.next = n3\nn3.next = n4\n
    linked_list.js
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.ts
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\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// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.dart
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nListNode n0 = ListNode(1);\nListNode n1 = ListNode(3);\nListNode n2 = ListNode(2);\nListNode n3 = ListNode(5);\nListNode n4 = ListNode(4);\n// Build references between nodes\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.rs
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// Build references between nodes\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\n
    linked_list.c
    /* Initialize linked list: 1 -> 3 -> 2 -> 5 -> 4 */\n// Initialize each node\nListNode* n0 = newListNode(1);\nListNode* n1 = newListNode(3);\nListNode* n2 = newListNode(2);\nListNode* n3 = newListNode(5);\nListNode* n4 = newListNode(4);\n// Build references between nodes\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.kt
    \n
    linked_list.zig
    // Initialize linked list\n// Initialize each node\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// Build references between nodes\nn0.next = &n1;\nn1.next = &n2;\nn2.next = &n3;\nn3.next = &n4;\n

    The array as a whole is a variable, for instance, the array nums includes elements like nums[0], nums[1], and so on, whereas a linked list is made up of several distinct node objects. We typically refer to a linked list by its head node, for example, the linked list in the previous code snippet is referred to as n0.

    "},{"location":"chapter_array_and_linkedlist/linked_list/#2-inserting-a-node","title":"2. \u00a0 Inserting a Node","text":"

    Inserting a node into a linked list is very easy. As shown in the figure, let's assume we aim to insert a new node P between two adjacent nodes n0 and n1. This can be achieved by simply modifying two node references (pointers), with a time complexity of \\(O(1)\\).

    By comparison, inserting an element into an array has a time complexity of \\(O(n)\\), which becomes less efficient when dealing with large data volumes.

    Figure 4-6 \u00a0 Linked List Node Insertion Example

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def insert(n0: ListNode, P: ListNode):\n    \"\"\"\u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0->next;\n    P->next = n1;\n    n0->next = P;\n}\n
    linked_list.java
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.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) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n
    linked_list.go
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.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) {\n    let n1 = n0.next\n    P.next = n1\n    n0.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) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.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 {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.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) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n
    linked_list.rs
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\n#[allow(non_snake_case)]\npub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(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) {\n    ListNode *n1 = n0->next;\n    P->next = n1;\n    n0->next = P;\n}\n
    linked_list.kt
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9p */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n
    linked_list.rb
    ### \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 _p ###\n# Ruby \u7684 `p` \u662f\u4e00\u4e2a\u5185\u7f6e\u51fd\u6570\uff0c `P` \u662f\u4e00\u4e2a\u5e38\u91cf\uff0c\u6240\u4ee5\u53ef\u4ee5\u4f7f\u7528 `_p` \u4ee3\u66ff\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\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 {\n    var n1 = n0.?.next;\n    P.?.next = n1;\n    n0.?.next = P;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#3-deleting-a-node","title":"3. \u00a0 Deleting a Node","text":"

    As shown in the figure, deleting a node from a linked list is also very easy, involving only the modification of a single node's reference (pointer).

    It's important to note that even though node P continues to point to n1 after being deleted, it becomes inaccessible during linked list traversal. This effectively means that P is no longer a part of the linked list.

    Figure 4-7 \u00a0 Linked List Node Deletion

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def remove(n0: ListNode):\n    \"\"\"\u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9\"\"\"\n    if not n0.next:\n        return\n    # n0 -> P -> n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n
    linked_list.cpp
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode *n0) {\n    if (n0->next == nullptr)\n        return;\n    // n0 -> P -> n1\n    ListNode *P = n0->next;\n    ListNode *n1 = P->next;\n    n0->next = n1;\n    // \u91ca\u653e\u5185\u5b58\n    delete P;\n}\n
    linked_list.java
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -> P -> n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n
    linked_list.cs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -> P -> n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n
    linked_list.go
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -> P -> n1\n    P := n0.Next\n    n1 := P.Next\n    n0.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) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -> P -> n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.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) {\n    if (!n0.next) return;\n    // n0 -> P -> n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.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 {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -> P -> n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.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) {\n  if (n0.next == null) return;\n  // n0 -> P -> n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n
    linked_list.rs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\n#[allow(non_snake_case)]\npub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {\n    if n0.borrow().next.is_none() {\n        return;\n    };\n    // n0 -> P -> n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\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 removeItem(ListNode *n0) {\n    if (!n0->next)\n        return;\n    // n0 -> P -> n1\n    ListNode *P = n0->next;\n    ListNode *n1 = P->next;\n    n0->next = n1;\n    // \u91ca\u653e\u5185\u5b58\n    free(P);\n}\n
    linked_list.kt
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfun remove(n0: ListNode?) {\n    val p = n0?.next\n    val n1 = p?.next\n    n0?.next = n1\n}\n
    linked_list.rb
    ### \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -> remove_node -> n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\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 {\n    if (n0.?.next == null) return;\n    // n0 -> P -> n1\n    var P = n0.?.next;\n    var n1 = P.?.next;\n    n0.?.next = n1;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#4-accessing-nodes","title":"4. \u00a0 Accessing Nodes","text":"

    Accessing nodes in a linked list is less efficient. As previously mentioned, any element in an array can be accessed in \\(O(1)\\) time. In contrast, with a linked list, the program involves starting from the head node and sequentially traversing through the nodes until the desired node is found. In other words, to access the \\(i\\)-th node in a linked list, the program must iterate through \\(i - 1\\) nodes, resulting in a time complexity of \\(O(n)\\).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def access(head: ListNode, index: int) -> ListNode | None:\n    \"\"\"\u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n
    linked_list.cpp
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head->next;\n    }\n    return head;\n}\n
    linked_list.java
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.cs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.go
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i < index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return 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? {\n    var head: ListNode? = head\n    for _ in 0 ..< index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n
    linked_list.js
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunction access(head, index) {\n    for (let i = 0; i < index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return 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 {\n    for (let i = 0; i < index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.dart
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i < index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n
    linked_list.rs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\npub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {\n    if index <= 0 {\n        return head;\n    };\n    if let Some(node) = &head.borrow().next {\n        return access(node.clone(), index - 1);\n    }\n\n    return head;\n}\n
    linked_list.c
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head->next;\n    }\n    return head;\n}\n
    linked_list.kt
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..<index) {\n        h = h?.next\n    }\n    return h\n}\n
    linked_list.rb
    ### \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\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) {\n    var head = node;\n    var i: i32 = 0;\n    while (i < index) : (i += 1) {\n        head = head.?.next;\n        if (head == null) return null;\n    }\n    return head;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#5-finding-nodes","title":"5. \u00a0 Finding Nodes","text":"

    Traverse the linked list to locate a node whose value matches target, and then output the index of that node within the linked list. This procedure is also an example of linear search. The corresponding code is provided below:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head->val == target)\n            return index;\n        head = head->next;\n        index++;\n    }\n    return -1;\n}\n
    linked_list.java
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -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) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\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 {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -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 {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n
    linked_list.js
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -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 {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -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) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n
    linked_list.rs
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\npub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {\n    if head.borrow().val == target {\n        return index;\n    };\n    if let Some(node) = &head.borrow_mut().next {\n        return find(node.clone(), target, index + 1);\n    }\n    return -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) {\n    int index = 0;\n    while (head) {\n        if (head->val == target)\n            return index;\n        head = head->next;\n        index++;\n    }\n    return -1;\n}\n
    linked_list.kt
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h.value == target) return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n
    linked_list.rb
    ### \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\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 {\n    var head = node;\n    var index: i32 = 0;\n    while (head != null) {\n        if (head.?.val == target) return index;\n        head = head.?.next;\n        index += 1;\n    }\n    return -1;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#422-arrays-vs-linked-lists","title":"4.2.2 \u00a0 Arrays vs. Linked Lists","text":"

    The Table 4-1 summarizes the characteristics of arrays and linked lists, and it also compares their efficiencies in various operations. Because they utilize opposing storage strategies, their respective properties and operational efficiencies exhibit distinct contrasts.

    Table 4-1 \u00a0 Efficiency Comparison of Arrays and Linked Lists

    Arrays Linked Lists Storage Contiguous Memory Space Dispersed Memory Space Capacity Expansion Fixed Length Flexible Expansion Memory Efficiency Less Memory per Element, Potential Space Wastage More Memory per Element Accessing Elements \\(O(1)\\) \\(O(n)\\) Adding Elements \\(O(n)\\) \\(O(1)\\) Deleting Elements \\(O(n)\\) \\(O(1)\\)"},{"location":"chapter_array_and_linkedlist/linked_list/#423-common-types-of-linked-lists","title":"4.2.3 \u00a0 Common Types of Linked Lists","text":"

    As shown in the figure, there are three common types of linked lists.

    • Singly Linked List: This is the standard linked list described earlier. Nodes in a singly linked list include a value and a reference to the next node. The first node is known as the head node, and the last node, which points to null (None), is the tail node.
    • Circular Linked List: This is formed when the tail node of a singly linked list points back to the head node, creating a loop. In a circular linked list, any node can function as the head node.
    • Doubly Linked List: In contrast to a singly linked list, a doubly linked list maintains references in two directions. Each node contains references (pointer) to both its successor (the next node) and predecessor (the previous node). Although doubly linked lists offer more flexibility for traversing in either direction, they also consume more memory space.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    class ListNode:\n    \"\"\"Bidirectional linked list node class\"\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Node value\n        self.next: ListNode | None = None  # Reference to the successor node\n        self.prev: ListNode | None = None  # Reference to a predecessor node\n
    /* Bidirectional linked list node structure */\nstruct ListNode {\n    int val;         // Node value\n    ListNode *next;  // Pointer to the successor node\n    ListNode *prev;  // Pointer to the predecessor node\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // Constructor\n};\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the next node\n    ListNode prev;  // Reference to the predecessor node\n    ListNode(int x) { val = x; }  // Constructor\n}\n
    /* Bidirectional linked list node class */\nclass ListNode(int x) {  // Constructor\n    int val = x;    // Node value\n    ListNode next;  // Reference to the next node\n    ListNode prev;  // Reference to the predecessor node\n}\n
    /* Bidirectional linked list node structure */\ntype DoublyListNode struct {\n    Val  int             // Node value\n    Next *DoublyListNode // Pointer to the successor node\n    Prev *DoublyListNode // Pointer to the predecessor node\n}\n\n// NewDoublyListNode initialization\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    var val: Int // Node value\n    var next: ListNode? // Reference to the next node\n    var prev: ListNode? // Reference to the predecessor node\n\n    init(x: Int) { // Constructor\n        val = x\n    }\n}\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // Node value\n        this.next = next  ===  undefined ? null : next;  // Reference to the successor node\n        this.prev = prev  ===  undefined ? null : prev;  // Reference to the predecessor node\n    }\n}\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // Node value\n        this.next = next  ===  undefined ? null : next;  // Reference to the successor node\n        this.prev = prev  ===  undefined ? null : prev;  // Reference to the predecessor node\n    }\n}\n
    /* Bidirectional linked list node class */\nclass ListNode {\n    int val;        // Node value\n    ListNode next;  // Reference to the next node\n    ListNode prev;  // Reference to the predecessor node\n    ListNode(this.val, [this.next, this.prev]);  // Constructor\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Bidirectional linked list node type */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // Node value\n    next: Option<Rc<RefCell<ListNode>>>, // Pointer to successor node\n    prev: Option<Rc<RefCell<ListNode>>>, // Pointer to predecessor node\n}\n\n/* Constructors */\nimpl ListNode {\n    fn new(val: i32) -> Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n
    /* Bidirectional linked list node structure */\ntypedef struct ListNode {\n    int val;               // Node value\n    struct ListNode *next; // Pointer to the successor node\n    struct ListNode *prev; // Pointer to the predecessor node\n} ListNode;\n\n/* Constructors */\nListNode *newListNode(int val) {\n    ListNode *node, *next;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node->val = val;\n    node->next = NULL;\n    node->prev = NULL;\n    return node;\n}\n
    \n
    // Bidirectional linked list node class\npub fn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = 0, // Node value\n        next: ?*Self = null, // Pointer to the successor node\n        prev: ?*Self = null, // Pointer to the predecessor node\n\n        // Constructor\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n            self.prev = null;\n        }\n    };\n}\n

    Figure 4-8 \u00a0 Common Types of Linked Lists

    "},{"location":"chapter_array_and_linkedlist/linked_list/#424-typical-applications-of-linked-lists","title":"4.2.4 \u00a0 Typical Applications of Linked Lists","text":"

    Singly linked lists are frequently utilized in implementing stacks, queues, hash tables, and graphs.

    • Stacks and Queues: In singly linked lists, if insertions and deletions occur at the same end, it behaves like a stack (last-in-first-out). Conversely, if insertions are at one end and deletions at the other, it functions like a queue (first-in-first-out).
    • Hash Tables: Linked lists are used in chaining, a popular method for resolving hash collisions. Here, all collided elements are grouped into a linked list.
    • Graphs: Adjacency lists, a standard method for graph representation, associate each graph vertex with a linked list. This list contains elements that represent vertices connected to the corresponding vertex.

    Doubly linked lists are ideal for scenarios requiring rapid access to preceding and succeeding elements.

    • Advanced Data Structures: In structures like red-black trees and B-trees, accessing a node's parent is essential. This is achieved by incorporating a reference to the parent node in each node, akin to a doubly linked list.
    • Browser History: In web browsers, doubly linked lists facilitate navigating the history of visited pages when users click forward or back.
    • LRU Algorithm: Doubly linked lists are apt for Least Recently Used (LRU) cache eviction algorithms, enabling swift identification of the least recently used data and facilitating fast node addition and removal.

    Circular linked lists are ideal for applications that require periodic operations, such as resource scheduling in operating systems.

    • Round-Robin Scheduling Algorithm: In operating systems, the round-robin scheduling algorithm is a common CPU scheduling method, requiring cycling through a group of processes. Each process is assigned a time slice, and upon expiration, the CPU rotates to the next process. This cyclical operation can be efficiently realized using a circular linked list, allowing for a fair and time-shared system among all processes.
    • Data Buffers: Circular linked lists are also used in data buffers, like in audio and video players, where the data stream is divided into multiple buffer blocks arranged in a circular fashion for seamless playback.
    "},{"location":"chapter_array_and_linkedlist/list/","title":"4.3 \u00a0 List","text":"

    A \"list\" is an abstract data structure concept that represents an ordered collection of elements, supporting operations such as element access, modification, addition, deletion, and traversal, without requiring users to consider capacity limitations. Lists can be implemented based on linked lists or arrays.

    • A linked list inherently serves as a list, supporting operations for adding, deleting, searching, and modifying elements, with the flexibility to dynamically adjust its size.
    • Arrays also support these operations, but due to their immutable length, they can be considered as a list with a length limit.

    When implementing lists using arrays, the immutability of length reduces the practicality of the list. This is because predicting the amount of data to be stored in advance is often challenging, making it difficult to choose an appropriate list length. If the length is too small, it may not meet the requirements; if too large, it may waste memory space.

    To solve this problem, we can implement lists using a \"dynamic array.\" It inherits the advantages of arrays and can dynamically expand during program execution.

    In fact, many programming languages' standard libraries implement lists using dynamic arrays, such as Python's list, Java's ArrayList, C++'s vector, and C#'s List. In the following discussion, we will consider \"list\" and \"dynamic array\" as synonymous concepts.

    "},{"location":"chapter_array_and_linkedlist/list/#431-common-list-operations","title":"4.3.1 \u00a0 Common List Operations","text":""},{"location":"chapter_array_and_linkedlist/list/#1-initializing-a-list","title":"1. \u00a0 Initializing a List","text":"

    We typically use two initialization methods: \"without initial values\" and \"with initial values\".

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Initialize list\n# Without initial values\nnums1: list[int] = []\n# With initial values\nnums: list[int] = [1, 3, 2, 5, 4]\n
    list.cpp
    /* Initialize list */\n// Note, in C++ the vector is the equivalent of nums described here\n// Without initial values\nvector<int> nums1;\n// With initial values\nvector<int> nums = { 1, 3, 2, 5, 4 };\n
    list.java
    /* Initialize list */\n// Without initial values\nList<Integer> nums1 = new ArrayList<>();\n// With initial values (note the element type should be the wrapper class Integer[] for int[])\nInteger[] numbers = new Integer[] { 1, 3, 2, 5, 4 };\nList<Integer> nums = new ArrayList<>(Arrays.asList(numbers));\n
    list.cs
    /* Initialize list */\n// Without initial values\nList<int> nums1 = [];\n// With initial values\nint[] numbers = [1, 3, 2, 5, 4];\nList<int> nums = [.. numbers];\n
    list_test.go
    /* Initialize list */\n// Without initial values\nnums1 := []int{}\n// With initial values\nnums := []int{1, 3, 2, 5, 4}\n
    list.swift
    /* Initialize list */\n// Without initial values\nlet nums1: [Int] = []\n// With initial values\nvar nums = [1, 3, 2, 5, 4]\n
    list.js
    /* Initialize list */\n// Without initial values\nconst nums1 = [];\n// With initial values\nconst nums = [1, 3, 2, 5, 4];\n
    list.ts
    /* Initialize list */\n// Without initial values\nconst nums1: number[] = [];\n// With initial values\nconst nums: number[] = [1, 3, 2, 5, 4];\n
    list.dart
    /* Initialize list */\n// Without initial values\nList<int> nums1 = [];\n// With initial values\nList<int> nums = [1, 3, 2, 5, 4];\n
    list.rs
    /* Initialize list */\n// Without initial values\nlet nums1: Vec<i32> = Vec::new();\n// With initial values\nlet nums: Vec<i32> = vec![1, 3, 2, 5, 4];\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Initialize list\nvar nums = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nums.deinit();\ntry nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });\n
    "},{"location":"chapter_array_and_linkedlist/list/#2-accessing-elements","title":"2. \u00a0 Accessing Elements","text":"

    Lists are essentially arrays, thus they can access and update elements in \\(O(1)\\) time, which is very efficient.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Access elements\nnum: int = nums[1]  # Access the element at index 1\n\n# Update elements\nnums[1] = 0    # Update the element at index 1 to 0\n
    list.cpp
    /* Access elements */\nint num = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list.java
    /* Access elements */\nint num = nums.get(1);  // Access the element at index 1\n\n/* Update elements */\nnums.set(1, 0);  // Update the element at index 1 to 0\n
    list.cs
    /* Access elements */\nint num = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list_test.go
    /* Access elements */\nnum := nums[1]  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0     // Update the element at index 1 to 0\n
    list.swift
    /* Access elements */\nlet num = nums[1] // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0 // Update the element at index 1 to 0\n
    list.js
    /* Access elements */\nconst num = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list.ts
    /* Access elements */\nconst num: number = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list.dart
    /* Access elements */\nint num = nums[1];  // Access the element at index 1\n\n/* Update elements */\nnums[1] = 0;  // Update the element at index 1 to 0\n
    list.rs
    /* Access elements */\nlet num: i32 = nums[1];  // Access the element at index 1\n/* Update elements */\nnums[1] = 0;             // Update the element at index 1 to 0\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Access elements\nvar num = nums.items[1]; // Access the element at index 1\n\n// Update elements\nnums.items[1] = 0; // Update the element at index 1 to 0  \n
    "},{"location":"chapter_array_and_linkedlist/list/#3-inserting-and-removing-elements","title":"3. \u00a0 Inserting and Removing Elements","text":"

    Compared to arrays, lists offer more flexibility in adding and removing elements. While adding elements to the end of a list is an \\(O(1)\\) operation, the efficiency of inserting and removing elements elsewhere in the list remains the same as in arrays, with a time complexity of \\(O(n)\\).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Clear list\nnums.clear()\n\n# Append elements at the end\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n# Insert element in the middle\nnums.insert(3, 6)  # Insert number 6 at index 3\n\n# Remove elements\nnums.pop(3)        # Remove the element at index 3\n
    list.cpp
    /* Clear list */\nnums.clear();\n\n/* Append elements at the end */\nnums.push_back(1);\nnums.push_back(3);\nnums.push_back(2);\nnums.push_back(5);\nnums.push_back(4);\n\n/* Insert element in the middle */\nnums.insert(nums.begin() + 3, 6);  // Insert number 6 at index 3\n\n/* Remove elements */\nnums.erase(nums.begin() + 3);      // Remove the element at index 3\n
    list.java
    /* Clear list */\nnums.clear();\n\n/* Append elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert element in the middle */\nnums.add(3, 6);  // Insert number 6 at index 3\n\n/* Remove elements */\nnums.remove(3);  // Remove the element at index 3\n
    list.cs
    /* Clear list */\nnums.Clear();\n\n/* Append elements at the end */\nnums.Add(1);\nnums.Add(3);\nnums.Add(2);\nnums.Add(5);\nnums.Add(4);\n\n/* Insert element in the middle */\nnums.Insert(3, 6);\n\n/* Remove elements */\nnums.RemoveAt(3);\n
    list_test.go
    /* Clear list */\nnums = nil\n\n/* Append elements at the end */\nnums = append(nums, 1)\nnums = append(nums, 3)\nnums = append(nums, 2)\nnums = append(nums, 5)\nnums = append(nums, 4)\n\n/* Insert element in the middle */\nnums = append(nums[:3], append([]int{6}, nums[3:]...)...) // Insert number 6 at index 3\n\n/* Remove elements */\nnums = append(nums[:3], nums[4:]...) // Remove the element at index 3\n
    list.swift
    /* Clear list */\nnums.removeAll()\n\n/* Append elements at the end */\nnums.append(1)\nnums.append(3)\nnums.append(2)\nnums.append(5)\nnums.append(4)\n\n/* Insert element in the middle */\nnums.insert(6, at: 3) // Insert number 6 at index 3\n\n/* Remove elements */\nnums.remove(at: 3) // Remove the element at index 3\n
    list.js
    /* Clear list */\nnums.length = 0;\n\n/* Append elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert element in the middle */\nnums.splice(3, 0, 6);\n\n/* Remove elements */\nnums.splice(3, 1);\n
    list.ts
    /* Clear list */\nnums.length = 0;\n\n/* Append elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert element in the middle */\nnums.splice(3, 0, 6);\n\n/* Remove elements */\nnums.splice(3, 1);\n
    list.dart
    /* Clear list */\nnums.clear();\n\n/* Append elements at the end */\nnums.add(1);\nnums.add(3);\nnums.add(2);\nnums.add(5);\nnums.add(4);\n\n/* Insert element in the middle */\nnums.insert(3, 6); // Insert number 6 at index 3\n\n/* Remove elements */\nnums.removeAt(3); // Remove the element at index 3\n
    list.rs
    /* Clear list */\nnums.clear();\n\n/* Append elements at the end */\nnums.push(1);\nnums.push(3);\nnums.push(2);\nnums.push(5);\nnums.push(4);\n\n/* Insert element in the middle */\nnums.insert(3, 6);  // Insert number 6 at index 3\n\n/* Remove elements */\nnums.remove(3);    // Remove the element at index 3\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Clear list\nnums.clearRetainingCapacity();\n\n// Append elements at the end\ntry nums.append(1);\ntry nums.append(3);\ntry nums.append(2);\ntry nums.append(5);\ntry nums.append(4);\n\n// Insert element in the middle\ntry nums.insert(3, 6); // Insert number 6 at index 3\n\n// Remove elements\n_ = nums.orderedRemove(3); // Remove the element at index 3\n
    "},{"location":"chapter_array_and_linkedlist/list/#4-iterating-the-list","title":"4. \u00a0 Iterating the List","text":"

    Similar to arrays, lists can be iterated either by using indices or by directly iterating through each element.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Iterate through the list by index\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# Iterate directly through list elements\nfor num in nums:\n    count += num\n
    list.cpp
    /* Iterate through the list by index */\nint count = 0;\nfor (int i = 0; i < nums.size(); i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n
    list.java
    /* Iterate through the list by index */\nint count = 0;\nfor (int i = 0; i < nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* Iterate directly through list elements */\nfor (int num : nums) {\n    count += num;\n}\n
    list.cs
    /* Iterate through the list by index */\nint count = 0;\nfor (int i = 0; i < nums.Count; i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n
    list_test.go
    /* Iterate through the list by index */\ncount := 0\nfor i := 0; i < len(nums); i++ {\n    count += nums[i]\n}\n\n/* Iterate directly through list elements */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n
    list.swift
    /* Iterate through the list by index */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* Iterate directly through list elements */\ncount = 0\nfor num in nums {\n    count += num\n}\n
    list.js
    /* Iterate through the list by index */\nlet count = 0;\nfor (let i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n
    list.ts
    /* Iterate through the list by index */\nlet count = 0;\nfor (let i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n
    list.dart
    /* Iterate through the list by index */\nint count = 0;\nfor (var i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* Iterate directly through list elements */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n
    list.rs
    // Iterate through the list by index\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// Iterate directly through list elements\n_count = 0;\nfor num in &nums {\n    _count += num;\n}\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Iterate through the list by index\nvar count: i32 = 0;\nvar i: i32 = 0;\nwhile (i < nums.items.len) : (i += 1) {\n    count += nums[i];\n}\n\n// Iterate directly through list elements\ncount = 0;\nfor (nums.items) |num| {\n    count += num;\n}\n
    "},{"location":"chapter_array_and_linkedlist/list/#5-concatenating-lists","title":"5. \u00a0 Concatenating Lists","text":"

    Given a new list nums1, we can append it to the end of the original list.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Concatenate two lists\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # Concatenate nums1 to the end of nums\n
    list.cpp
    /* Concatenate two lists */\nvector<int> nums1 = { 6, 8, 7, 10, 9 };\n// Concatenate nums1 to the end of nums\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n
    list.java
    /* Concatenate two lists */\nList<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // Concatenate nums1 to the end of nums\n
    list.cs
    /* Concatenate two lists */\nList<int> nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // Concatenate nums1 to the end of nums\n
    list_test.go
    /* Concatenate two lists */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // Concatenate nums1 to the end of nums\n
    list.swift
    /* Concatenate two lists */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // Concatenate nums1 to the end of nums\n
    list.js
    /* Concatenate two lists */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Concatenate nums1 to the end of nums\n
    list.ts
    /* Concatenate two lists */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // Concatenate nums1 to the end of nums\n
    list.dart
    /* Concatenate two lists */\nList<int> nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // Concatenate nums1 to the end of nums\n
    list.rs
    /* Concatenate two lists */\nlet nums1: Vec<i32> = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Concatenate two lists\nvar nums1 = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nums1.deinit();\ntry nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });\ntry nums.insertSlice(nums.items.len, nums1.items); // Concatenate nums1 to the end of nums\n
    "},{"location":"chapter_array_and_linkedlist/list/#6-sorting-the-list","title":"6. \u00a0 Sorting the List","text":"

    Once the list is sorted, we can employ algorithms commonly used in array-related algorithm problems, such as \"binary search\" and \"two-pointer\" algorithms.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig list.py
    # Sort the list\nnums.sort()  # After sorting, the list elements are in ascending order\n
    list.cpp
    /* Sort the list */\nsort(nums.begin(), nums.end());  // After sorting, the list elements are in ascending order\n
    list.java
    /* Sort the list */\nCollections.sort(nums);  // After sorting, the list elements are in ascending order\n
    list.cs
    /* Sort the list */\nnums.Sort(); // After sorting, the list elements are in ascending order\n
    list_test.go
    /* Sort the list */\nsort.Ints(nums)  // After sorting, the list elements are in ascending order\n
    list.swift
    /* Sort the list */\nnums.sort() // After sorting, the list elements are in ascending order\n
    list.js
    /* Sort the list */  \nnums.sort((a, b) => a - b);  // After sorting, the list elements are in ascending order\n
    list.ts
    /* Sort the list */\nnums.sort((a, b) => a - b);  // After sorting, the list elements are in ascending order\n
    list.dart
    /* Sort the list */\nnums.sort(); // After sorting, the list elements are in ascending order\n
    list.rs
    /* Sort the list */\nnums.sort(); // After sorting, the list elements are in ascending order\n
    list.c
    // C does not provide built-in dynamic arrays\n
    list.kt
    \n
    list.zig
    // Sort the list\nstd.sort.sort(i32, nums.items, {}, comptime std.sort.asc(i32));\n
    "},{"location":"chapter_array_and_linkedlist/list/#432-list-implementation","title":"4.3.2 \u00a0 List Implementation","text":"

    Many programming languages come with built-in lists, including Java, C++, Python, etc. Their implementations tend to be intricate, featuring carefully considered settings for various parameters, like initial capacity and expansion factors. Readers who are curious can delve into the source code for further learning.

    To enhance our understanding of how lists work, we will attempt to implement a simplified version of a list, focusing on three crucial design aspects:

    • Initial Capacity: Choose a reasonable initial capacity for the array. In this example, we choose 10 as the initial capacity.
    • Size Recording: Declare a variable size to record the current number of elements in the list, updating in real-time with element insertion and deletion. With this variable, we can locate the end of the list and determine whether expansion is needed.
    • Expansion Mechanism: If the list reaches full capacity upon an element insertion, an expansion process is required. This involves creating a larger array based on the expansion factor, and then transferring all elements from the current array to the new one. In this example, we stipulate that the array size should double with each expansion.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_list.py
    class MyList:\n    \"\"\"\u5217\u8868\u7c7b\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._capacity: int = 10  # \u5217\u8868\u5bb9\u91cf\n        self._arr: list[int] = [0] * self._capacity  # \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        self._size: int = 0  # \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        self._extend_ratio: int = 2  # \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\"\"\"\n        return self._size\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u5217\u8868\u5bb9\u91cf\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -> int:\n        \"\"\"\u8bbf\u95ee\u5143\u7d20\"\"\"\n        # \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"\u66f4\u65b0\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"\u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\"\"\"\n        # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"\u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self._size += 1\n\n    def remove(self, index: int) -> int:\n        \"\"\"\u5220\u9664\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        num = self._arr[index]\n        # \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self._size -= 1\n        # \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n\n    def extend_capacity(self):\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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        self._capacity = len(self._arr)\n\n    def to_array(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u6709\u6548\u957f\u5ea6\u7684\u5217\u8868\"\"\"\n        return self._arr[: self._size]\n
    my_list.cpp
    /* \u5217\u8868\u7c7b */\nclass MyList {\n  private:\n    int *arr;             // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    int arrCapacity = 10; // \u5217\u8868\u5bb9\u91cf\n    int arrSize = 0;      // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    int extendRatio = 2;   // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    int size() {\n        return arrSize;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    int get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    void set(int index, int num) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    void add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    void insert(int index, int num) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size() == capacity())\n            extendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = size() - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    int remove(int index) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    void extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // \u91ca\u653e\u5185\u5b58\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Vector \u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> vec(size());\n        for (int i = 0; i < size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n
    my_list.java
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private int[] arr; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private int capacity = 10; // \u5217\u8868\u5bb9\u91cf\n    private int size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private int extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\n    public int size() {\n        return size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public int get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public void set(int index, int num) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public void add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public void insert(int index, int num) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = size - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public int remove(int index) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public 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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        capacity = arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public int[] toArray() {\n        int size = size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] arr = new int[size];\n        for (int i = 0; i < size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.cs
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private int[] arr;           // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private int arrCapacity = 10;    // \u5217\u8868\u5bb9\u91cf\n    private int arrSize = 0;         // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private readonly int extendRatio = 2;  // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    public int Size() {\n        return arrSize;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public int Get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public void Set(int index, int num) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public void Add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public void Insert(int index, int num) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = arrSize - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public int Remove(int index) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public void ExtendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a arrCapacity * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        arrCapacity = arr.Length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] arr = new int[arrSize];\n        for (int i = 0; i < arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.go
    /* \u5217\u8868\u7c7b */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newMyList() *myList {\n    return &myList{\n        arrCapacity: 10,              // \u5217\u8868\u5bb9\u91cf\n        arr:         make([]int, 10), // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        arrSize:     0,               // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        extendRatio: 2,               // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n    }\n}\n\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/*  \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nfunc (l *myList) get(index int) int {\n    // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    return l.arr[index]\n}\n\n/* \u66f4\u65b0\u5143\u7d20 */\nfunc (l *myList) set(num, index int) {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    l.arr[index] = num\n}\n\n/* \u5728\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\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize++\n}\n\n/* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nfunc (l *myList) insert(num, index int) {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for j := l.arrSize - 1; j >= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize++\n}\n\n/* \u5220\u9664\u5143\u7d20 */\nfunc (l *myList) remove(index int) int {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    num := l.arr[index]\n    // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for j := index; j < l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize--\n    // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    return num\n}\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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    l.arrCapacity = len(l.arr)\n}\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\n    return l.arr[:l.arrSize]\n}\n
    my_list.swift
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private var arr: [Int] // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private var _capacity: Int // \u5217\u8868\u5bb9\u91cf\n    private var _size: Int // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private let extendRatio: Int // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    func size() -> Int {\n        _size\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    func capacity() -> Int {\n        _capacity\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    func get(index: Int) -> Int {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u9519\u8bef\uff0c\u4e0b\u540c\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        return arr[index]\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    func set(index: Int, num: Int) {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        arr[index] = num\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    func add(num: Int) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size += 1\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    func insert(index: Int, num: Int) {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in (index ..< size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size += 1\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    @discardableResult\n    func remove(index: Int) -> Int {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        let num = arr[index]\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in index ..< (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size -= 1\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    func extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        _capacity = arr.count\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    func toArray() -> [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n
    my_list.js
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    #arr = 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\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    #extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    size() {\n        return this.#size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    get(index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        return this.#arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    set(index, num) {\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        this.#arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    add(num) {\n        // \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    insert(index, num) {\n        if (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\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (let j = this.#size - 1; j >= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    remove(index) {\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        let num = this.#arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (let j = index; j < this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.#size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        this.#capacity = this.#arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    toArray() {\n        let size = this.size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(size);\n        for (let i = 0; i < size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.ts
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private arr: Array<number>; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private _capacity: number = 10; // \u5217\u8868\u5bb9\u91cf\n    private _size: number = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private extendRatio: number = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    public size(): number {\n        return this._size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public get(index: number): number {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        return this.arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public set(index: number, num: number): void {\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        this.arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public add(num: number): void {\n        // \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\n        if (this._size === this._capacity) this.extendCapacity();\n        // \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public insert(index: number, num: number): void {\n        if (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\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (let j = this._size - 1; j >= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public remove(index: number): number {\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        let num = this.arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (let j = index; j < this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this._size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public extendCapacity(): void {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        this._capacity = this.arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public toArray(): number[] {\n        let size = this.size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(size);\n        for (let i = 0; i < size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.dart
    /* \u5217\u8868\u7c7b */\nclass MyList {\n  late List<int> _arr; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n  int _capacity = 10; // \u5217\u8868\u5bb9\u91cf\n  int _size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n  int _extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n  int size() => _size;\n\n  /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n  int capacity() => _capacity;\n\n  /* \u8bbf\u95ee\u5143\u7d20 */\n  int get(int index) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    return _arr[index];\n  }\n\n  /* \u66f4\u65b0\u5143\u7d20 */\n  void set(int index, int _num) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    _arr[index] = _num;\n  }\n\n  /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n  void add(int _num) {\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size++;\n  }\n\n  /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n  void insert(int index, int _num) {\n    if (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\n    if (_size == _capacity) extendCapacity();\n    // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for (var j = _size - 1; j >= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size++;\n  }\n\n  /* \u5220\u9664\u5143\u7d20 */\n  int remove(int index) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    int _num = _arr[index];\n    // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (var j = index; j < _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size--;\n    // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    return _num;\n  }\n\n  /* \u5217\u8868\u6269\u5bb9 */\n  void extendCapacity() {\n    // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 _extendRatio \u500d\u7684\u65b0\u6570\u7ec4\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // \u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    List.copyRange(_newNums, 0, _arr);\n    // \u66f4\u65b0 _arr \u7684\u5f15\u7528\n    _arr = _newNums;\n    // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    _capacity = _arr.length;\n  }\n\n  /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n  List<int> toArray() {\n    List<int> arr = [];\n    for (var i = 0; i < _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n
    my_list.rs
    /* \u5217\u8868\u7c7b */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec<i32>,       // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    capacity: usize,     // \u5217\u8868\u5bb9\u91cf\n    size: usize,         // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    extend_ratio: usize, // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(capacity: usize) -> Self {\n        let mut vec = Vec::new();\n        vec.resize(capacity, 0);\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    pub fn size(&self) -> usize {\n        return self.size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    pub fn capacity(&self) -> usize {\n        return self.capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    pub fn get(&self, index: usize) -> i32 {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if index >= self.size {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        return self.arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    pub fn set(&mut self, index: usize, num: i32) {\n        if index >= self.size {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    pub fn add(&mut self, num: i32) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size += 1;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    pub fn insert(&mut self, index: usize, num: i32) {\n        if index >= self.size() {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size += 1;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    pub fn remove(&mut self, index: usize) -> i32 {\n        if index >= self.size() {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        let num = self.arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in (index..self.size - 1) {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size -= 1;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    pub fn extend_capacity(&mut self) {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        self.capacity = new_capacity;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    pub fn to_array(&mut self) -> Vec<i32> {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n
    my_list.c
    /* \u5217\u8868\u7c7b */\ntypedef struct {\n    int *arr;        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    int capacity;    // \u5217\u8868\u5bb9\u91cf\n    int size;        // \u5217\u8868\u5927\u5c0f\n    int extendRatio; // \u5217\u8868\u6bcf\u6b21\u6269\u5bb9\u7684\u500d\u6570\n} MyList;\n\n/* \u6784\u9020\u51fd\u6570 */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums->capacity = 10;\n    nums->arr = malloc(sizeof(int) * nums->capacity);\n    nums->size = 0;\n    nums->extendRatio = 2;\n    return nums;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delMyList(MyList *nums) {\n    free(nums->arr);\n    free(nums);\n}\n\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6 */\nint size(MyList *nums) {\n    return nums->size;\n}\n\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity(MyList *nums) {\n    return nums->capacity;\n}\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(MyList *nums, int index) {\n    assert(index >= 0 && index < nums->size);\n    return nums->arr[index];\n}\n\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(MyList *nums, int index, int num) {\n    assert(index >= 0 && index < nums->size);\n    nums->arr[index] = num;\n}\n\n/* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // \u6269\u5bb9\n    }\n    nums->arr[size(nums)] = num;\n    nums->size++;\n}\n\n/* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index >= 0 && index < size(nums));\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // \u6269\u5bb9\n    }\n    for (int i = size(nums); i > index; --i) {\n        nums->arr[i] = nums->arr[i - 1];\n    }\n    nums->arr[index] = num;\n    nums->size++;\n}\n\n/* \u5220\u9664\u5143\u7d20 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nint removeItem(MyList *nums, int index) {\n    assert(index >= 0 && index < size(nums));\n    int num = nums->arr[index];\n    for (int i = index; i < size(nums) - 1; i++) {\n        nums->arr[i] = nums->arr[i + 1];\n    }\n    nums->size--;\n    return num;\n}\n\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity(MyList *nums) {\n    // \u5148\u5206\u914d\u7a7a\u95f4\n    int newCapacity = capacity(nums) * nums->extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums->arr;\n\n    // \u62f7\u8d1d\u65e7\u6570\u636e\u5230\u65b0\u6570\u636e\n    for (int i = 0; i < size(nums); i++)\n        extend[i] = nums->arr[i];\n\n    // \u91ca\u653e\u65e7\u6570\u636e\n    free(temp);\n\n    // \u66f4\u65b0\u65b0\u6570\u636e\n    nums->arr = extend;\n    nums->capacity = newCapacity;\n}\n\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Array \u7528\u4e8e\u6253\u5370 */\nint *toArray(MyList *nums) {\n    return nums->arr;\n}\n
    my_list.kt
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private var capacity = 10 // \u5217\u8868\u5bb9\u91cf\n    private var size = 0 // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private var extendRatio = 2 // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\n    fun size(): Int {\n        return size\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    fun get(index: Int): Int {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException()\n        return arr[index]\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    fun set(index: Int, num: Int) {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        arr[index] = num\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    fun add(num: Int) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    fun insert(index: Int, num: Int) {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity()\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    fun remove(index: Int): Int {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        val num: Int = arr[index]\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (j in index..<size - 1)\n            arr[j] = arr[j + 1]\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size--\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    fun extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = arr.copyOf(capacity() * extendRatio)\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        capacity = arr.size\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    fun toArray(): IntArray {\n        val size = size()\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val arr = IntArray(size)\n        for (i in 0..<size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n
    my_list.rb
    ### \u5217\u8868\u7c7b ###\nclass MyList\n  attr_reader :size       # \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n  attr_reader :capacity   # \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\n\n  ### \u6784\u9020\u65b9\u6cd5 ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new capacity\n  end\n\n  ### \u8bbf\u95ee\u5143\u7d20 ###\n  def get(index)\n    # \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    @arr[index]\n  end\n\n  ### \u8bbf\u95ee\u5143\u7d20 ###\n  def set(index, num)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    @arr[index] = num\n  end\n\n  ### \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 ###\n  def add(num)\n    # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size += 1\n  end\n\n  ### \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 ###\n  def insert(index, num)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n\n    # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    extend_capacity if size == capacity\n\n    # \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j] \n    end\n    @arr[index] = num\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size += 1\n  end\n\n  ### \u5220\u9664\u5143\u7d20 ###\n  def remove(index)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    num = @arr[index]\n\n    # \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size -= 1\n\n    # \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    num\n  end\n\n  ### \u5217\u8868\u6269\u5bb9 ###\n  def extend_capacity\n    # \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    @capacity = arr.length\n  end\n\n  ### \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 ###\n  def to_array\n    sz = size\n    # \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    arr = Array.new sz\n    for i in 0...sz\n      arr[i] = get i\n    end\n    arr\n  end\nend\n
    my_list.zig
    // \u5217\u8868\u7c7b\nfn MyList(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        arr: []T = undefined,                        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        arrCapacity: usize = 10,                     // \u5217\u8868\u5bb9\u91cf\n        numSize: usize = 0,                           // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        extendRatio: usize = 2,                       // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined, // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u5217\u8868\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);\n            @memset(self.arr, @as(T, 0));\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        pub fn size(self: *Self) usize {\n            return self.numSize;\n        }\n\n        // \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\n        pub fn capacity(self: *Self) usize {\n            return self.arrCapacity;\n        }\n\n        // \u8bbf\u95ee\u5143\u7d20\n        pub fn get(self: *Self, index: usize) T {\n            // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            return self.arr[index];\n        }  \n\n        // \u66f4\u65b0\u5143\u7d20\n        pub fn set(self: *Self, index: usize, num: T) void {\n            // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            self.arr[index] = num;\n        }  \n\n        // \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\n        pub fn add(self: *Self, num: T) !void {\n            // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n            if (self.size() == self.capacity()) try self.extendCapacity();\n            self.arr[self.size()] = num;\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize += 1;\n        }  \n\n        // \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\n        pub fn insert(self: *Self, index: usize, num: T) !void {\n            if (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\n            if (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\n            var j = self.size() - 1;\n            while (j >= index) : (j -= 1) {\n                self.arr[j + 1] = self.arr[j];\n            }\n            self.arr[index] = num;\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize += 1;\n        }\n\n        // \u5220\u9664\u5143\u7d20\n        pub fn remove(self: *Self, index: usize) T {\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            var num = self.arr[index];\n            // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n            var j = index;\n            while (j < self.size() - 1) : (j += 1) {\n                self.arr[j] = self.arr[j + 1];\n            }\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize -= 1;\n            // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n            return num;\n        }\n\n        // \u5217\u8868\u6269\u5bb9\n        pub fn extendCapacity(self: *Self) !void {\n            // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n            var newCapacity = self.capacity() * self.extendRatio;\n            var 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\n            std.mem.copy(T, extend, self.arr);\n            self.arr = extend;\n            // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n            self.arrCapacity = newCapacity;\n        }\n\n        // \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n            var arr = try self.mem_allocator.alloc(T, self.size());\n           @memset(arr, @as(T, 0));\n            for (arr, 0..) |*num, i| {\n                num.* = self.get(i);\n            }\n            return arr;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/","title":"4.4 \u00a0 Memory and Cache *","text":"

    In the first two sections of this chapter, we explored arrays and linked lists, two fundamental and important data structures, representing \"continuous storage\" and \"dispersed storage\" respectively.

    In fact, the physical structure largely determines the efficiency of a program's use of memory and cache, which in turn affects the overall performance of the algorithm.

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441-computer-storage-devices","title":"4.4.1 \u00a0 Computer Storage Devices","text":"

    There are three types of storage devices in computers: \"hard disk,\" \"random-access memory (RAM),\" and \"cache memory.\" The following table shows their different roles and performance characteristics in computer systems.

    Table 4-2 \u00a0 Computer Storage Devices

    Hard Disk Memory Cache Usage Long-term storage of data, including OS, programs, files, etc. Temporary storage of currently running programs and data being processed Stores frequently accessed data and instructions, reducing the number of CPU accesses to memory Volatility Data is not lost after power off Data is lost after power off Data is lost after power off Capacity Larger, TB level Smaller, GB level Very small, MB level Speed Slower, several hundred to thousands MB/s Faster, several tens of GB/s Very fast, several tens to hundreds of GB/s Price Cheaper, several cents to yuan / GB More expensive, tens to hundreds of yuan / GB Very expensive, priced with CPU

    We can imagine the computer storage system as a pyramid structure shown in the Figure 4-9 . The storage devices closer to the top of the pyramid are faster, have smaller capacity, and are more costly. This multi-level design is not accidental, but the result of careful consideration by computer scientists and engineers.

    • Hard disks are difficult to replace with memory. Firstly, data in memory is lost after power off, making it unsuitable for long-term data storage; secondly, the cost of memory is dozens of times that of hard disks, making it difficult to popularize in the consumer market.
    • It is difficult for caches to have both large capacity and high speed. As the capacity of L1, L2, L3 caches gradually increases, their physical size becomes larger, increasing the physical distance from the CPU core, leading to increased data transfer time and higher element access latency. Under current technology, a multi-level cache structure is the best balance between capacity, speed, and cost.

    Figure 4-9 \u00a0 Computer Storage System

    Note

    The storage hierarchy of computers reflects a delicate balance between speed, capacity, and cost. In fact, this kind of trade-off is common in all industrial fields, requiring us to find the best balance between different advantages and limitations.

    Overall, hard disks are used for long-term storage of large amounts of data, memory is used for temporary storage of data being processed during program execution, and cache is used to store frequently accessed data and instructions to improve program execution efficiency. Together, they ensure the efficient operation of computer systems.

    As shown in the Figure 4-10 , during program execution, data is read from the hard disk into memory for CPU computation. The cache can be considered a part of the CPU, smartly loading data from memory to provide fast data access to the CPU, significantly enhancing program execution efficiency and reducing reliance on slower memory.

    Figure 4-10 \u00a0 Data Flow Between Hard Disk, Memory, and Cache

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442-memory-efficiency-of-data-structures","title":"4.4.2 \u00a0 Memory Efficiency of Data Structures","text":"

    In terms of memory space utilization, arrays and linked lists have their advantages and limitations.

    On one hand, memory is limited and cannot be shared by multiple programs, so we hope that data structures can use space as efficiently as possible. The elements of an array are tightly packed without extra space for storing references (pointers) between linked list nodes, making them more space-efficient. However, arrays require allocating sufficient continuous memory space at once, which may lead to memory waste, and array expansion also requires additional time and space costs. In contrast, linked lists allocate and reclaim memory dynamically on a per-node basis, providing greater flexibility.

    On the other hand, during program execution, as memory is repeatedly allocated and released, the degree of fragmentation of free memory becomes higher, leading to reduced memory utilization efficiency. Arrays, due to their continuous storage method, are relatively less likely to cause memory fragmentation. In contrast, the elements of a linked list are dispersedly stored, and frequent insertion and deletion operations make memory fragmentation more likely.

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443-cache-efficiency-of-data-structures","title":"4.4.3 \u00a0 Cache Efficiency of Data Structures","text":"

    Although caches are much smaller in space capacity than memory, they are much faster and play a crucial role in program execution speed. Since the cache's capacity is limited and can only store a small part of frequently accessed data, when the CPU tries to access data not in the cache, a \"cache miss\" occurs, forcing the CPU to load the needed data from slower memory.

    Clearly, the fewer the cache misses, the higher the CPU's data read-write efficiency, and the better the program performance. The proportion of successful data retrieval from the cache by the CPU is called the \"cache hit rate,\" a metric often used to measure cache efficiency.

    To achieve higher efficiency, caches adopt the following data loading mechanisms.

    • Cache Lines: Caches don't store and load data byte by byte but in units of cache lines. Compared to byte-by-byte transfer, the transmission of cache lines is more efficient.
    • Prefetch Mechanism: Processors try to predict data access patterns (such as sequential access, fixed stride jumping access, etc.) and load data into the cache according to specific patterns to improve the hit rate.
    • Spatial Locality: If data is accessed, data nearby is likely to be accessed in the near future. Therefore, when loading certain data, the cache also loads nearby data to improve the hit rate.
    • Temporal Locality: If data is accessed, it's likely to be accessed again in the near future. Caches use this principle to retain recently accessed data to improve the hit rate.

    In fact, arrays and linked lists have different cache utilization efficiencies, mainly reflected in the following aspects.

    • Occupied Space: Linked list elements occupy more space than array elements, resulting in less effective data volume in the cache.
    • Cache Lines: Linked list data is scattered throughout memory, and since caches load \"by line,\" the proportion of loading invalid data is higher.
    • Prefetch Mechanism: The data access pattern of arrays is more \"predictable\" than that of linked lists, meaning the system is more likely to guess which data will be loaded next.
    • Spatial Locality: Arrays are stored in concentrated memory spaces, so the data near the loaded data is more likely to be accessed next.

    Overall, arrays have a higher cache hit rate and are generally more efficient in operation than linked lists. This makes data structures based on arrays more popular in solving algorithmic problems.

    It should be noted that high cache efficiency does not mean that arrays are always better than linked lists. Which data structure to choose in actual applications should be based on specific requirements. For example, both arrays and linked lists can implement the \"stack\" data structure (which will be detailed in the next chapter), but they are suitable for different scenarios.

    • In algorithm problems, we tend to choose stacks based on arrays because they provide higher operational efficiency and random access capabilities, with the only cost being the need to pre-allocate a certain amount of memory space for the array.
    • If the data volume is very large, highly dynamic, and the expected size of the stack is difficult to estimate, then a stack based on a linked list is more appropriate. Linked lists can disperse a large amount of data in different parts of the memory and avoid the additional overhead of array expansion.
    "},{"location":"chapter_array_and_linkedlist/summary/","title":"4.5 \u00a0 Summary","text":""},{"location":"chapter_array_and_linkedlist/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"
    • Arrays and linked lists are two basic data structures, representing two storage methods in computer memory: contiguous space storage and non-contiguous space storage. Their characteristics complement each other.
    • Arrays support random access and use less memory; however, they are inefficient in inserting and deleting elements and have a fixed length after initialization.
    • Linked lists implement efficient node insertion and deletion through changing references (pointers) and can flexibly adjust their length; however, they have lower node access efficiency and consume more memory.
    • Common types of linked lists include singly linked lists, circular linked lists, and doubly linked lists, each with its own application scenarios.
    • Lists are ordered collections of elements that support addition, deletion, and modification, typically implemented based on dynamic arrays, retaining the advantages of arrays while allowing flexible length adjustment.
    • The advent of lists significantly enhanced the practicality of arrays but may lead to some memory space wastage.
    • During program execution, data is mainly stored in memory. Arrays provide higher memory space efficiency, while linked lists are more flexible in memory usage.
    • Caches provide fast data access to CPUs through mechanisms like cache lines, prefetching, spatial locality, and temporal locality, significantly enhancing program execution efficiency.
    • Due to higher cache hit rates, arrays are generally more efficient than linked lists. When choosing a data structure, the appropriate choice should be made based on specific needs and scenarios.
    "},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Does storing arrays on the stack versus the heap affect time and space efficiency?

    Arrays stored on both the stack and heap are stored in contiguous memory spaces, and data operation efficiency is essentially the same. However, stacks and heaps have their own characteristics, leading to the following differences.

    1. Allocation and release efficiency: The stack is a smaller memory block, allocated automatically by the compiler; the heap memory is relatively larger and can be dynamically allocated in the code, more prone to fragmentation. Therefore, allocation and release operations on the heap are generally slower than on the stack.
    2. Size limitation: Stack memory is relatively small, while the heap size is generally limited by available memory. Therefore, the heap is more suitable for storing large arrays.
    3. Flexibility: The size of arrays on the stack needs to be determined at compile-time, while the size of arrays on the heap can be dynamically determined at runtime.

    Q: Why do arrays require elements of the same type, while linked lists do not emphasize same-type elements?

    Linked lists consist of nodes connected by references (pointers), and each node can store data of different types, such as int, double, string, object, etc.

    In contrast, array elements must be of the same type, allowing the calculation of offsets to access the corresponding element positions. For example, an array containing both int and long types, with single elements occupying 4 bytes and 8 bytes respectively, cannot use the following formula to calculate offsets, as the array contains elements of two different lengths.

    # Element memory address = Array memory address + Element length * Element index\n

    Q: After deleting a node, is it necessary to set P.next to None?

    Not modifying P.next is also acceptable. From the perspective of the linked list, traversing from the head node to the tail node will no longer encounter P. This means that node P has been effectively removed from the list, and where P points no longer affects the list.

    From a garbage collection perspective, for languages with automatic garbage collection mechanisms like Java, Python, and Go, whether node P is collected depends on whether there are still references pointing to it, not on the value of P.next. In languages like C and C++, we need to manually free the node's memory.

    Q: In linked lists, the time complexity for insertion and deletion operations is O(1). But searching for the element before insertion or deletion takes O(n) time, so why isn't the time complexity O(n)?

    If an element is searched first and then deleted, the time complexity is indeed O(n). However, the O(1) advantage of linked lists in insertion and deletion can be realized in other applications. For example, in the implementation of double-ended queues using linked lists, we maintain pointers always pointing to the head and tail nodes, making each insertion and deletion operation O(1).

    Q: In the image \"Linked List Definition and Storage Method\", do the light blue storage nodes occupy a single memory address, or do they share half with the node value?

    The diagram is just a qualitative representation; quantitative analysis depends on specific situations.

    • Different types of node values occupy different amounts of space, such as int, long, double, and object instances.
    • The memory space occupied by pointer variables depends on the operating system and compilation environment used, usually 8 bytes or 4 bytes.

    Q: Is adding elements to the end of a list always O(1)?

    If adding an element exceeds the list length, the list needs to be expanded first. The system will request a new memory block and move all elements of the original list over, in which case the time complexity becomes O(n).

    Q: The statement \"The emergence of lists greatly improves the practicality of arrays, but may lead to some memory space wastage\" - does this refer to the memory occupied by additional variables like capacity, length, and expansion multiplier?

    The space wastage here mainly refers to two aspects: on the one hand, lists are set with an initial length, which we may not always need; on the other hand, to prevent frequent expansion, expansion usually multiplies by a coefficient, such as \\(\\times 1.5\\). This results in many empty slots, which we typically cannot fully fill.

    Q: In Python, after initializing n = [1, 2, 3], the addresses of these 3 elements are contiguous, but initializing m = [2, 1, 3] shows that each element's id is not consecutive but identical to those in n. If the addresses of these elements are not contiguous, is m still an array?

    If we replace list elements with linked list nodes n = [n1, n2, n3, n4, n5], these 5 node objects are also typically dispersed throughout memory. However, given a list index, we can still access the node's memory address in O(1) time, thereby accessing the corresponding node. This is because the array stores references to the nodes, not the nodes themselves.

    Unlike many languages, in Python, numbers are also wrapped as objects, and lists store references to these numbers, not the numbers themselves. Therefore, we find that the same number in two arrays has the same id, and these numbers' memory addresses need not be contiguous.

    Q: The std::list in C++ STL has already implemented a doubly linked list, but it seems that some algorithm books don't directly use it. Is there any limitation?

    On the one hand, we often prefer to use arrays to implement algorithms, only using linked lists when necessary, mainly for two reasons.

    • Space overhead: Since each element requires two additional pointers (one for the previous element and one for the next), std::list usually occupies more space than std::vector.
    • Cache unfriendly: As the data is not stored continuously, std::list has a lower cache utilization rate. Generally, std::vector performs better.

    On the other hand, linked lists are primarily necessary for binary trees and graphs. Stacks and queues are often implemented using the programming language's stack and queue classes, rather than linked lists.

    Q: Does initializing a list res = [0] * self.size() result in each element of res referencing the same address?

    No. However, this issue arises with two-dimensional arrays, for example, initializing a two-dimensional list res = [[0] * self.size()] would reference the same list [0] multiple times.

    Q: In deleting a node, is it necessary to break the reference to its successor node?

    From the perspective of data structures and algorithms (problem-solving), it's okay not to break the link, as long as the program's logic is correct. From the perspective of standard libraries, breaking the link is safer and more logically clear. If the link is not broken, and the deleted node is not properly recycled, it could affect the recycling of the successor node's memory.

    "},{"location":"chapter_computational_complexity/","title":"Chapter 2. \u00a0 Complexity Analysis","text":"

    Abstract

    Complexity analysis is like a space-time navigator in the vast universe of algorithms.

    It guides us in exploring deeper within the the dimensions of time and space, seeking more elegant solutions.

    "},{"location":"chapter_computational_complexity/#chapter-contents","title":"Chapter Contents","text":"
    • 2.1 \u00a0 Algorithm Efficiency Assessment
    • 2.2 \u00a0 Iteration and Recursion
    • 2.3 \u00a0 Time Complexity
    • 2.4 \u00a0 Space Complexity
    • 2.5 \u00a0 Summary
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/","title":"2.2 \u00a0 Iteration and Recursion","text":"

    In algorithms, the repeated execution of a task is quite common and is closely related to the analysis of complexity. Therefore, before delving into the concepts of time complexity and space complexity, let's first explore how to implement repetitive tasks in programming. This involves understanding two fundamental programming control structures: iteration and recursion.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#221-iteration","title":"2.2.1 \u00a0 Iteration","text":"

    \"Iteration\" is a control structure for repeatedly performing a task. In iteration, a program repeats a block of code as long as a certain condition is met until this condition is no longer satisfied.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for-loops","title":"1. \u00a0 For Loops","text":"

    The for loop is one of the most common forms of iteration, and it's particularly suitable when the number of iterations is known in advance.

    The following function uses a for loop to perform a summation of \\(1 + 2 + \\dots + n\\), with the sum being stored in the variable res. It's important to note that in Python, range(a, b) creates an interval that is inclusive of a but exclusive of b, meaning it iterates over the range from \\(a\\) up to \\(b\u22121\\).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def for_loop(n: int) -> int:\n    \"\"\"for \u5faa\u73af\"\"\"\n    res = 0\n    # \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n
    iteration.cpp
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.java
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.cs
    /* for \u5faa\u73af */\nint ForLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.go
    /* for \u5faa\u73af */\nfunc forLoop(n int) int {\n    res := 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i := 1; i <= n; i++ {\n        res += i\n    }\n    return res\n}\n
    iteration.swift
    /* for \u5faa\u73af */\nfunc forLoop(n: Int) -> Int {\n    var res = 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n
    iteration.js
    /* for \u5faa\u73af */\nfunction forLoop(n) {\n    let res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.ts
    /* for \u5faa\u73af */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.dart
    /* for \u5faa\u73af */\nint forLoop(int n) {\n  int res = 0;\n  // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n  for (int i = 1; i <= n; i++) {\n    res += i;\n  }\n  return res;\n}\n
    iteration.rs
    /* for \u5faa\u73af */\nfn for_loop(n: i32) -> i32 {\n    let mut res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n
    iteration.c
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.kt
    /* for \u5faa\u73af */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{for_loop}\n
    iteration.zig
    // for \u5faa\u73af\nfn forLoop(n: usize) i32 {\n    var res: i32 = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (1..n+1) |i| {\n        res = res + @as(i32, @intCast(i));\n    }\n    return res;\n} \n
    Code Visualization

    Full Screen >

    The flowchart below represents this sum function.

    Figure 2-1 \u00a0 Flowchart of the Sum Function

    The number of operations in this summation function is proportional to the size of the input data \\(n\\), or in other words, it has a \"linear relationship.\" This \"linear relationship\" is what time complexity describes. This topic will be discussed in more detail in the next section.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while-loops","title":"2. \u00a0 While Loops","text":"

    Similar to for loops, while loops are another approach for implementing iteration. In a while loop, the program checks a condition at the beginning of each iteration; if the condition is true, the execution continues, otherwise, the loop ends.

    Below we use a while loop to implement the sum \\(1 + 2 + \\dots + n\\).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def while_loop(n: int) -> int:\n    \"\"\"while \u5faa\u73af\"\"\"\n    res = 0\n    i = 1  # \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    # \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n:\n        res += i\n        i += 1  # \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    return res\n
    iteration.cpp
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.java
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.cs
    /* while \u5faa\u73af */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i += 1; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.go
    /* while \u5faa\u73af */\nfunc whileLoop(n int) int {\n    res := 0\n    // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    i := 1\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n    }\n    return res\n}\n
    iteration.swift
    /* while \u5faa\u73af */\nfunc whileLoop(n: Int) -> Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n {\n        res += i\n        i += 1 // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res\n}\n
    iteration.js
    /* while \u5faa\u73af */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.ts
    /* while \u5faa\u73af */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.dart
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n  // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n  while (i <= n) {\n    res += i;\n    i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n  }\n  return res;\n}\n
    iteration.rs
    /* while \u5faa\u73af */\nfn while_loop(n: i32) -> i32 {\n    let mut res = 0;\n    let mut i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n {\n        res += i;\n        i += 1; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    res\n}\n
    iteration.c
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.kt
    /* while \u5faa\u73af */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i\n        i++ // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{while_loop}\n
    iteration.zig
    // while \u5faa\u73af\nfn whileLoop(n: i32) i32 {\n    var res: i32 = 0;\n    var i: i32 = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += @intCast(i);\n        i += 1;\n    }\n    return res;\n}\n
    Code Visualization

    Full Screen >

    While loops provide more flexibility than for loops, especially since they allow for custom initialization and modification of the condition variable at each step.

    For example, in the following code, the condition variable \\(i\\) is updated twice each round, which would be inconvenient to implement with a for loop.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def while_loop_ii(n: int) -> int:\n    \"\"\"while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09\"\"\"\n    res = 0\n    i = 1  # \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    # \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n:\n        res += i\n        # \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1\n        i *= 2\n    return res\n
    iteration.cpp
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.java
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.cs
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n
    iteration.go
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunc whileLoopII(n int) int {\n    res := 0\n    // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    i := 1\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    for i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n        i *= 2\n    }\n    return res\n}\n
    iteration.swift
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunc whileLoopII(n: Int) -> Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1\n        i *= 2\n    }\n    return res\n}\n
    iteration.js
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.ts
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.dart
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n  // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n  while (i <= n) {\n    res += i;\n    // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n
    iteration.rs
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfn while_loop_ii(n: i32) -> i32 {\n    let mut res = 0;\n    let mut i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n
    iteration.c
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.kt
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n        i *= 2\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{while_loop_ii}\n
    iteration.zig
    //  while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09\nfn whileLoopII(n: i32) i32 {\n    var res: i32 = 0;\n    var i: i32 = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += @intCast(i);\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1;\n        i *= 2;\n    }\n    return res;\n}\n
    Code Visualization

    Full Screen >

    Overall, for loops are more concise, while while loops are more flexible. Both can implement iterative structures. Which one to use should be determined based on the specific requirements of the problem.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#3-nested-loops","title":"3. \u00a0 Nested Loops","text":"

    We can nest one loop structure within another. Below is an example using for loops:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def nested_for_loop(n: int) -> str:\n    \"\"\"\u53cc\u5c42 for \u5faa\u73af\"\"\"\n    res = \"\"\n    # \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n
    iteration.cpp
    /* \u53cc\u5c42 for \u5faa\u73af */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; ++i) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; ++j) {\n            res << \"(\" << i << \", \" << j << \"), \";\n        }\n    }\n    return res.str();\n}\n
    iteration.java
    /* \u53cc\u5c42 for \u5faa\u73af */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n
    iteration.cs
    /* \u53cc\u5c42 for \u5faa\u73af */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n
    iteration.go
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i := 1; i <= n; i++ {\n        for j := 1; j <= n; j++ {\n            // \u5faa\u73af j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n
    iteration.swift
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunc nestedForLoop(n: Int) -> String {\n    var res = \"\"\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n
    iteration.js
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunction nestedForLoop(n) {\n    let res = '';\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (let j = 1; j <= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n
    iteration.ts
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (let j = 1; j <= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n
    iteration.dart
    /* \u53cc\u5c42 for \u5faa\u73af */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // \u5faa\u73af i = 1, 2, ..., n-1, n\n  for (int i = 1; i <= n; i++) {\n    // \u5faa\u73af j = 1, 2, ..., n-1, n\n    for (int j = 1; j <= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n
    iteration.rs
    /* \u53cc\u5c42 for \u5faa\u73af */\nfn nested_for_loop(n: i32) -> String {\n    let mut res = vec![];\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n
    iteration.c
    /* \u53cc\u5c42 for \u5faa\u73af */\nchar *nestedForLoop(int n) {\n    // n * n \u4e3a\u5bf9\u5e94\u70b9\u6570\u91cf\uff0c\"(i, j), \" \u5bf9\u5e94\u5b57\u7b26\u4e32\u957f\u6700\u5927\u4e3a 6+10*2\uff0c\u52a0\u4e0a\u6700\u540e\u4e00\u4e2a\u7a7a\u5b57\u7b26 \\0 \u7684\u989d\u5916\u7a7a\u95f4\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n
    iteration.kt
    /* \u53cc\u5c42 for \u5faa\u73af */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n
    iteration.rb
    [class]{}-[func]{nested_for_loop}\n
    iteration.zig
    // \u53cc\u5c42 for \u5faa\u73af\nfn nestedForLoop(allocator: Allocator, n: usize) ![]const u8 {\n    var res = std.ArrayList(u8).init(allocator);\n    defer res.deinit();\n    var buffer: [20]u8 = undefined;\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (1..n+1) |i| {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (1..n+1) |j| {\n            var _str = try std.fmt.bufPrint(&buffer, \"({d}, {d}), \", .{i, j});\n            try res.appendSlice(_str);\n        }\n    }\n    return res.toOwnedSlice();\n}\n
    Code Visualization

    Full Screen >

    The flowchart below represents this nested loop.

    Figure 2-2 \u00a0 Flowchart of the Nested Loop

    In such cases, the number of operations of the function is proportional to \\(n^2\\), meaning the algorithm's runtime and the size of the input data \\(n\\) has a 'quadratic relationship.'

    We can further increase the complexity by adding more nested loops, each level of nesting effectively \"increasing the dimension,\" which raises the time complexity to \"cubic,\" \"quartic,\" and so on.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#222-recursion","title":"2.2.2 \u00a0 Recursion","text":"

    \"Recursion\" is an algorithmic strategy where a function solves a problem by calling itself. It primarily involves two phases:

    1. Calling: This is where the program repeatedly calls itself, often with progressively smaller or simpler arguments, moving towards the \"termination condition.\"
    2. Returning: Upon triggering the \"termination condition,\" the program begins to return from the deepest recursive function, aggregating the results of each layer.

    From an implementation perspective, recursive code mainly includes three elements.

    1. Termination Condition: Determines when to switch from \"calling\" to \"returning.\"
    2. Recursive Call: Corresponds to \"calling,\" where the function calls itself, usually with smaller or more simplified parameters.
    3. Return Result: Corresponds to \"returning,\" where the result of the current recursion level is returned to the previous layer.

    Observe the following code, where simply calling the function recur(n) can compute the sum of \\(1 + 2 + \\dots + n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def recur(n: int) -> int:\n    \"\"\"\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if n == 1:\n        return 1\n    # \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    res = recur(n - 1)\n    # \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n
    recursion.cpp
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.java
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.cs
    /* \u9012\u5f52 */\nint Recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = Recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.go
    /* \u9012\u5f52 */\nfunc recur(n int) int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    res := recur(n - 1)\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.swift
    /* \u9012\u5f52 */\nfunc recur(n: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    let res = recur(n: n - 1)\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.js
    /* \u9012\u5f52 */\nfunction recur(n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 1) return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    const res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.ts
    /* \u9012\u5f52 */\nfunction recur(n: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 1) return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    const res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.dart
    /* \u9012\u5f52 */\nint recur(int n) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (n == 1) return 1;\n  // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n  int res = recur(n - 1);\n  // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n  return n + res;\n}\n
    recursion.rs
    /* \u9012\u5f52 */\nfn recur(n: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1;\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    let res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    n + res\n}\n
    recursion.c
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.kt
    /* \u9012\u5f52 */\nfun recur(n: Int): Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1\n    // \u9012: \u9012\u5f52\u8c03\u7528\n    val res = recur(n - 1)\n    // \u5f52: \u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.rb
    [class]{}-[func]{recur}\n
    recursion.zig
    // \u9012\u5f52\u51fd\u6570\nfn recur(n: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1) {\n        return 1;\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    var res: i32 = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    Code Visualization

    Full Screen >

    The Figure 2-3 shows the recursive process of this function.

    Figure 2-3 \u00a0 Recursive Process of the Sum Function

    Although iteration and recursion can achieve the same results from a computational standpoint, they represent two entirely different paradigms of thinking and problem-solving.

    • Iteration: Solves problems \"from the bottom up.\" It starts with the most basic steps, and then repeatedly adds or accumulates these steps until the task is complete.
    • Recursion: Solves problems \"from the top down.\" It breaks down the original problem into smaller sub-problems, each of which has the same form as the original problem. These sub-problems are then further decomposed into even smaller sub-problems, stopping at the base case whose solution is known.

    Let's take the earlier example of the summation function, defined as \\(f(n) = 1 + 2 + \\dots + n\\).

    • Iteration: In this approach, we simulate the summation process within a loop. Starting from \\(1\\) and traversing to \\(n\\), we perform the summation operation in each iteration to eventually compute \\(f(n)\\).
    • Recursion: Here, the problem is broken down into a sub-problem: \\(f(n) = n + f(n-1)\\). This decomposition continues recursively until reaching the base case, \\(f(1) = 1\\), at which point the recursion terminates.
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-call-stack","title":"1. \u00a0 Call Stack","text":"

    Every time a recursive function calls itself, the system allocates memory for the newly initiated function to store local variables, the return address, and other relevant information. This leads to two primary outcomes.

    • The function's context data is stored in a memory area called \"stack frame space\" and is only released after the function returns. Therefore, recursion generally consumes more memory space than iteration.
    • Recursive calls introduce additional overhead. Hence, recursion is usually less time-efficient than loops.

    As shown in the Figure 2-4 , there are \\(n\\) unreturned recursive functions before triggering the termination condition, indicating a recursion depth of \\(n\\).

    Figure 2-4 \u00a0 Recursion Call Depth

    In practice, the depth of recursion allowed by programming languages is usually limited, and excessively deep recursion can lead to stack overflow errors.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-tail-recursion","title":"2. \u00a0 Tail Recursion","text":"

    Interestingly, if a function performs its recursive call as the very last step before returning, it can be optimized by the compiler or interpreter to be as space-efficient as iteration. This scenario is known as \"tail recursion.\"

    • Regular Recursion: In standard recursion, when the function returns to the previous level, it continues to execute more code, requiring the system to save the context of the previous call.
    • Tail Recursion: Here, the recursive call is the final operation before the function returns. This means that upon returning to the previous level, no further actions are needed, so the system does not need to save the context of the previous level.

    For example, in calculating \\(1 + 2 + \\dots + n\\), we can make the result variable res a parameter of the function, thereby achieving tail recursion:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def tail_recur(n, res):\n    \"\"\"\u5c3e\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if n == 0:\n        return res\n    # \u5c3e\u9012\u5f52\u8c03\u7528\n    return tail_recur(n - 1, res + n)\n
    recursion.cpp
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.java
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.cs
    /* \u5c3e\u9012\u5f52 */\nint TailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return TailRecur(n - 1, res + n);\n}\n
    recursion.go
    /* \u5c3e\u9012\u5f52 */\nfunc tailRecur(n int, res int) int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n-1, res+n)\n}\n
    recursion.swift
    /* \u5c3e\u9012\u5f52 */\nfunc tailRecur(n: Int, res: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n: n - 1, res: res + n)\n}\n
    recursion.js
    /* \u5c3e\u9012\u5f52 */\nfunction tailRecur(n, res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 0) return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.ts
    /* \u5c3e\u9012\u5f52 */\nfunction tailRecur(n: number, res: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 0) return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.dart
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (n == 0) return res;\n  // \u5c3e\u9012\u5f52\u8c03\u7528\n  return tailRecur(n - 1, res + n);\n}\n
    recursion.rs
    /* \u5c3e\u9012\u5f52 */\nfn tail_recur(n: i32, res: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res;\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    tail_recur(n - 1, res + n)\n}\n
    recursion.c
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.kt
    /* \u5c3e\u9012\u5f52 */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // \u6dfb\u52a0 tailrec \u5173\u952e\u8bcd\uff0c\u4ee5\u5f00\u542f\u5c3e\u9012\u5f52\u4f18\u5316\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n)\n}\n
    recursion.rb
    [class]{}-[func]{tail_recur}\n
    recursion.zig
    // \u5c3e\u9012\u5f52\u51fd\u6570\nfn tailRecur(n: i32, res: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0) {\n        return res;\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    Code Visualization

    Full Screen >

    The execution process of tail recursion is shown in the following figure. Comparing regular recursion and tail recursion, the point of the summation operation is different.

    • Regular Recursion: The summation operation occurs during the \"returning\" phase, requiring another summation after each layer returns.
    • Tail Recursion: The summation operation occurs during the \"calling\" phase, and the \"returning\" phase only involves returning through each layer.

    Figure 2-5 \u00a0 Tail Recursion Process

    Tip

    Note that many compilers or interpreters do not support tail recursion optimization. For example, Python does not support tail recursion optimization by default, so even if the function is in the form of tail recursion, it may still encounter stack overflow issues.

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#3-recursion-tree","title":"3. \u00a0 Recursion Tree","text":"

    When dealing with algorithms related to \"divide and conquer\", recursion often offers a more intuitive approach and more readable code than iteration. Take the \"Fibonacci sequence\" as an example.

    Question

    Given a Fibonacci sequence \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\), find the \\(n\\)th number in the sequence.

    Let the \\(n\\)th number of the Fibonacci sequence be \\(f(n)\\), it's easy to deduce two conclusions:

    • The first two numbers of the sequence are \\(f(1) = 0\\) and \\(f(2) = 1\\).
    • Each number in the sequence is the sum of the two preceding ones, that is, \\(f(n) = f(n - 1) + f(n - 2)\\).

    Using the recursive relation, and considering the first two numbers as termination conditions, we can write the recursive code. Calling fib(n) will yield the \\(n\\)th number of the Fibonacci sequence:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def fib(n: int) -> int:\n    \"\"\"\u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n
    recursion.cpp
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.java
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.cs
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint Fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.go
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunc fib(n int) int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.swift
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunc fib(n: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.js
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunction fib(n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.ts
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunction fib(n: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.dart
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n  // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // \u8fd4\u56de\u7ed3\u679c f(n)\n  return res;\n}\n
    recursion.rs
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfn fib(n: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c\n    res\n}\n
    recursion.c
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.kt
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfun fib(n: Int): Int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.rb
    [class]{}-[func]{fib}\n
    recursion.zig
    // \u6590\u6ce2\u90a3\u5951\u6570\u5217\nfn fib(n: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 or n == 2) {\n        return n - 1;\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    var res: i32 = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    Code Visualization

    Full Screen >

    Observing the above code, we see that it recursively calls two functions within itself, meaning that one call generates two branching calls. As illustrated below, this continuous recursive calling eventually creates a \"recursion tree\" with a depth of \\(n\\).

    Figure 2-6 \u00a0 Fibonacci Sequence Recursion Tree

    Fundamentally, recursion embodies the paradigm of \"breaking down a problem into smaller sub-problems.\" This divide-and-conquer strategy is crucial.

    • From an algorithmic perspective, many important strategies like searching, sorting, backtracking, divide-and-conquer, and dynamic programming directly or indirectly use this way of thinking.
    • From a data structure perspective, recursion is naturally suited for dealing with linked lists, trees, and graphs, as they are well suited for analysis using the divide-and-conquer approach.
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#223-comparison","title":"2.2.3 \u00a0 Comparison","text":"

    Summarizing the above content, the following table shows the differences between iteration and recursion in terms of implementation, performance, and applicability.

    Table: Comparison of Iteration and Recursion Characteristics

    Iteration Recursion Approach Loop structure Function calls itself Time Efficiency Generally higher efficiency, no function call overhead Each function call generates overhead Memory Usage Typically uses a fixed size of memory space Accumulative function calls can use a substantial amount of stack frame space Suitable Problems Suitable for simple loop tasks, intuitive and readable code Suitable for problem decomposition, like trees, graphs, divide-and-conquer, backtracking, etc., concise and clear code structure

    Tip

    If you find the following content difficult to understand, consider revisiting it after reading the \"Stack\" chapter.

    So, what is the intrinsic connection between iteration and recursion? Taking the above recursive function as an example, the summation operation occurs during the recursion's \"return\" phase. This means that the initially called function is the last to complete its summation operation, mirroring the \"last in, first out\" principle of a stack.

    Recursive terms like \"call stack\" and \"stack frame space\" hint at the close relationship between recursion and stacks.

    1. Calling: When a function is called, the system allocates a new stack frame on the \"call stack\" for that function, storing local variables, parameters, return addresses, and other data.
    2. Returning: When a function completes execution and returns, the corresponding stack frame is removed from the \"call stack,\" restoring the execution environment of the previous function.

    Therefore, we can use an explicit stack to simulate the behavior of the call stack, thus transforming recursion into an iterative form:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def for_loop_recur(n: int) -> int:\n    \"\"\"\u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52\"\"\"\n    # \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack = []\n    res = 0\n    # \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in range(n, 0, -1):\n        # \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.append(i)\n    # \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while stack:\n        # \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n
    recursion.cpp
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack<int> stack;\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (!stack.empty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.java
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    Stack<Integer> stack = new Stack<>();\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (!stack.isEmpty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.cs
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint ForLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    Stack<int> stack = new();\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.Push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.Count > 0) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.go
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunc forLoopRecur(n int) int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack := list.New()\n    res := 0\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i := n; i > 0; i-- {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.PushBack(i)\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    for stack.Len() != 0 {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.swift
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunc forLoopRecur(n: Int) -> Int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    var stack: [Int] = []\n    var res = 0\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in (1 ... n).reversed() {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.append(i)\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while !stack.isEmpty {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.js
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunction forLoopRecur(n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    const stack = [];\n    let res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (let i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.length) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.ts
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunction forLoopRecur(n: number): number {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808 \n    const stack: number[] = [];\n    let res: number = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (let i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.length) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.dart
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n  // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n  List<int> stack = [];\n  int res = 0;\n  // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n  for (int i = n; i > 0; i--) {\n    // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n    stack.add(i);\n  }\n  // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n  while (!stack.isEmpty) {\n    // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n
    recursion.rs
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfn for_loop_recur(n: i32) -> i32 {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in (1..=n).rev() {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while !stack.is_empty() {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n
    recursion.c
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    int stack[1000]; // \u501f\u52a9\u4e00\u4e2a\u5927\u6570\u7ec4\u6765\u6a21\u62df\u6808\n    int top = -1;    // \u6808\u9876\u7d22\u5f15\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack[1 + top++] = i;\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (top >= 0) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.kt
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfun forLoopRecur(n: Int): Int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    val stack = Stack<Int>()\n    var res = 0\n    // \u9012: \u9012\u5f52\u8c03\u7528\n    for (i in n downTo 0) {\n        stack.push(i)\n    }\n    // \u5f52: \u8fd4\u56de\u7ed3\u679c\n    while (stack.isNotEmpty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.rb
    [class]{}-[func]{for_loop_recur}\n
    recursion.zig
    // \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52\nfn forLoopRecur(comptime n: i32) i32 {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    var stack: [n]i32 = undefined;\n    var res: i32 = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    var i: usize = n;\n    while (i > 0) {\n        stack[i - 1] = @intCast(i);\n        i -= 1;\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    var index: usize = n;\n    while (index > 0) {\n        index -= 1;\n        res += stack[index];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    Code Visualization

    Full Screen >

    Observing the above code, when recursion is transformed into iteration, the code becomes more complex. Although iteration and recursion can often be transformed into each other, it's not always advisable to do so for two reasons:

    • The transformed code may become more challenging to understand and less readable.
    • For some complex problems, simulating the behavior of the system's call stack can be quite challenging.

    In conclusion, whether to choose iteration or recursion depends on the specific nature of the problem. In programming practice, it's crucial to weigh the pros and cons of both and choose the most suitable approach for the situation at hand.

    "},{"location":"chapter_computational_complexity/performance_evaluation/","title":"2.1 \u00a0 Algorithm Efficiency Assessment","text":"

    In algorithm design, we pursue the following two objectives in sequence.

    1. Finding a Solution to the Problem: The algorithm should reliably find the correct solution within the stipulated range of inputs.
    2. Seeking the Optimal Solution: For the same problem, multiple solutions might exist, and we aim to find the most efficient algorithm possible.

    In other words, under the premise of being able to solve the problem, algorithm efficiency has become the main criterion for evaluating the merits of an algorithm, which includes the following two dimensions.

    • Time Efficiency: The speed at which an algorithm runs.
    • Space Efficiency: The size of the memory space occupied by an algorithm.

    In short, our goal is to design data structures and algorithms that are both fast and memory-efficient. Effectively assessing algorithm efficiency is crucial because only then can we compare various algorithms and guide the process of algorithm design and optimization.

    There are mainly two methods of efficiency assessment: actual testing and theoretical estimation.

    "},{"location":"chapter_computational_complexity/performance_evaluation/#211-actual-testing","title":"2.1.1 \u00a0 Actual Testing","text":"

    Suppose we have algorithms A and B, both capable of solving the same problem, and we need to compare their efficiencies. The most direct method is to use a computer to run these two algorithms and monitor and record their runtime and memory usage. This assessment method reflects the actual situation but has significant limitations.

    On one hand, it's difficult to eliminate interference from the testing environment. Hardware configurations can affect algorithm performance. For example, algorithm A might run faster than B on one computer, but the opposite result may occur on another computer with different configurations. This means we would need to test on a variety of machines to calculate average efficiency, which is impractical.

    On the other hand, conducting a full test is very resource-intensive. As the volume of input data changes, the efficiency of the algorithms may vary. For example, with smaller data volumes, algorithm A might run faster than B, but the opposite might be true with larger data volumes. Therefore, to draw convincing conclusions, we need to test a wide range of input data sizes, which requires significant computational resources.

    "},{"location":"chapter_computational_complexity/performance_evaluation/#212-theoretical-estimation","title":"2.1.2 \u00a0 Theoretical Estimation","text":"

    Due to the significant limitations of actual testing, we can consider evaluating algorithm efficiency solely through calculations. This estimation method is known as \"asymptotic complexity analysis,\" or simply \"complexity analysis.\"

    Complexity analysis reflects the relationship between the time and space resources required for algorithm execution and the size of the input data. It describes the trend of growth in the time and space required by the algorithm as the size of the input data increases. This definition might sound complex, but we can break it down into three key points to understand it better.

    • \"Time and space resources\" correspond to \"time complexity\" and \"space complexity,\" respectively.
    • \"As the size of input data increases\" means that complexity reflects the relationship between algorithm efficiency and the volume of input data.
    • \"The trend of growth in time and space\" indicates that complexity analysis focuses not on the specific values of runtime or space occupied but on the \"rate\" at which time or space grows.

    Complexity analysis overcomes the disadvantages of actual testing methods, reflected in the following aspects:

    • It is independent of the testing environment and applicable to all operating platforms.
    • It can reflect algorithm efficiency under different data volumes, especially in the performance of algorithms with large data volumes.

    Tip

    If you're still confused about the concept of complexity, don't worry. We will introduce it in detail in subsequent chapters.

    Complexity analysis provides us with a \"ruler\" to measure the time and space resources needed to execute an algorithm and compare the efficiency between different algorithms.

    Complexity is a mathematical concept and may be abstract and challenging for beginners. From this perspective, complexity analysis might not be the best content to introduce first. However, when discussing the characteristics of a particular data structure or algorithm, it's hard to avoid analyzing its speed and space usage.

    In summary, it's recommended that you establish a preliminary understanding of complexity analysis before diving deep into data structures and algorithms, so that you can carry out simple complexity analyses of algorithms.

    "},{"location":"chapter_computational_complexity/space_complexity/","title":"2.4 \u00a0 Space Complexity","text":"

    \"Space complexity\" is used to measure the growth trend of the memory space occupied by an algorithm as the amount of data increases. This concept is very similar to time complexity, except that \"running time\" is replaced with \"occupied memory space\".

    "},{"location":"chapter_computational_complexity/space_complexity/#241-space-related-to-algorithms","title":"2.4.1 \u00a0 Space Related to Algorithms","text":"

    The memory space used by an algorithm during its execution mainly includes the following types.

    • Input Space: Used to store the input data of the algorithm.
    • Temporary Space: Used to store variables, objects, function contexts, and other data during the algorithm's execution.
    • Output Space: Used to store the output data of the algorithm.

    Generally, the scope of space complexity statistics includes both \"Temporary Space\" and \"Output Space\".

    Temporary space can be further divided into three parts.

    • Temporary Data: Used to save various constants, variables, objects, etc., during the algorithm's execution.
    • Stack Frame Space: Used to save the context data of the called function. The system creates a stack frame at the top of the stack each time a function is called, and the stack frame space is released after the function returns.
    • Instruction Space: Used to store compiled program instructions, which are usually negligible in actual statistics.

    When analyzing the space complexity of a program, we typically count the Temporary Data, Stack Frame Space, and Output Data, as shown in the Figure 2-15 .

    Figure 2-15 \u00a0 Space Types Used in Algorithms

    The relevant code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    class Node:\n    \"\"\"Classes\"\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x               # node value\n        self.next: Node | None = None   # reference to the next node\n\ndef function() -> int:\n    \"\"\"\"Functions\"\"\"\"\"\n    # Perform certain operations...\n    return 0\n\ndef algorithm(n) -> int:    # input data\n    A = 0                   # temporary data (constant, usually in uppercase)\n    b = 0                   # temporary data (variable)\n    node = Node(0)          # temporary data (object)\n    c = function()          # Stack frame space (call function)\n    return A + b + c        # output data\n
    /* Structures */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* Functions */\nint func() {\n    // Perform certain operations...\n    return 0;\n}\n\nint algorithm(int n) {          // input data\n    const int a = 0;            // temporary data (constant)\n    int b = 0;                  // temporary data (variable)\n    Node* node = new Node(0);   // temporary data (object)\n    int c = func();             // stack frame space (call function)\n    return a + b + c;           // output data\n}\n
    /* Classes */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* Functions */\nint function() {\n    // Perform certain operations...\n    return 0;\n}\n\nint algorithm(int n) {          // input data\n    final int a = 0;            // temporary data (constant)\n    int b = 0;                  // temporary data (variable)\n    Node node = new Node(0);    // temporary data (object)\n    int c = function();         // stack frame space (call function)\n    return a + b + c;           // output data\n}\n
    /* Classes */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* Functions */\nint Function() {\n    // Perform certain operations...\n    return 0;\n}\n\nint Algorithm(int n) {  // input data\n    const int a = 0;    // temporary data (constant)\n    int b = 0;          // temporary data (variable)\n    Node node = new(0); // temporary data (object)\n    int c = Function(); // stack frame space (call function)\n    return a + b + c;   // output data\n}\n
    /* Structures */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* Create node structure */\nfunc newNode(val int) *node {\n    return &node{val: val}\n}\n\n/* Functions */\nfunc function() int {\n    // Perform certain operations...\n    return 0\n}\n\nfunc algorithm(n int) int { // input data\n    const a = 0             // temporary data (constant)\n    b := 0                  // temporary storage of data (variable)\n    newNode(0)              // temporary data (object)\n    c := function()         // stack frame space (call function)\n    return a + b + c        // output data\n}\n
    /* Classes */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* Functions */\nfunc function() -> Int {\n    // Perform certain operations...\n    return 0\n}\n\nfunc algorithm(n: Int) -> Int { // input data\n    let a = 0                   // temporary data (constant)\n    var b = 0                   // temporary data (variable)\n    let node = Node(x: 0)       // temporary data (object)\n    let c = function()          // stack frame space (call function)\n    return a + b + c            // output data\n}\n
    /* Classes */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // node value\n        this.next = null;                       // reference to the next node\n    }\n}\n\n/* Functions */\nfunction constFunc() {\n    // Perform certain operations\n    return 0;\n}\n\nfunction algorithm(n) {         // input data\n    const a = 0;                // temporary data (constant)\n    let b = 0;                  // temporary data (variable)\n    const node = new Node(0);   // temporary data (object)\n    const c = constFunc();      // Stack frame space (calling function)\n    return a + b + c;           // output data\n}\n
    /* Classes */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // node value\n        this.next = null;                       // reference to the next node\n    }\n}\n\n/* Functions */\nfunction constFunc(): number {\n    // Perform certain operations\n    return 0;\n}\n\nfunction algorithm(n: number): number { // input data\n    const a = 0;                        // temporary data (constant)\n    let b = 0;                          // temporary data (variable)\n    const node = new Node(0);           // temporary data (object)\n    const c = constFunc();              // Stack frame space (calling function)\n    return a + b + c;                   // output data\n}\n
    /* Classes */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* Functions */\nint function() {\n  // Perform certain operations...\n  return 0;\n}\n\nint algorithm(int n) {  // input data\n  const int a = 0;      // temporary data (constant)\n  int b = 0;            // temporary data (variable)\n  Node node = Node(0);  // temporary data (object)\n  int c = function();   // stack frame space (call function)\n  return a + b + c;     // output data\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Structures */\nstruct Node {\n    val: i32,\n    next: Option<Rc<RefCell<Node>>>,\n}\n\n/* Creating a Node structure */\nimpl Node {\n    fn new(val: i32) -> Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* Functions */\nfn function() -> i32 {     \n    // Perform certain operations...\n    return 0;\n}\n\nfn algorithm(n: i32) -> i32 {   // input data\n    const a: i32 = 0;           // temporary data (constant)\n    let mut b = 0;              // temporary data (variable)\n    let node = Node::new(0);    // temporary data (object)\n    let c = function();         // stack frame space (call function)\n    return a + b + c;           // output data\n}\n
    /* Functions */\nint func() {\n    // Perform certain operations...\n    return 0;\n}\n\nint algorithm(int n) {  // input data\n    const int a = 0;    // temporary data (constant)\n    int b = 0;          // temporary data (variable)\n    int c = func();     // stack frame space (call function)\n    return a + b + c;   // output data\n}\n
    \n
    \n
    "},{"location":"chapter_computational_complexity/space_complexity/#242-calculation-method","title":"2.4.2 \u00a0 Calculation Method","text":"

    The method for calculating space complexity is roughly similar to that of time complexity, with the only change being the shift of the statistical object from \"number of operations\" to \"size of used space\".

    However, unlike time complexity, we usually only focus on the worst-case space complexity. This is because memory space is a hard requirement, and we must ensure that there is enough memory space reserved under all input data.

    Consider the following code, the term \"worst-case\" in worst-case space complexity has two meanings.

    1. Based on the worst input data: When \\(n < 10\\), the space complexity is \\(O(1)\\); but when \\(n > 10\\), the initialized array nums occupies \\(O(n)\\) space, thus the worst-case space complexity is \\(O(n)\\).
    2. Based on the peak memory used during the algorithm's execution: For example, before executing the last line, the program occupies \\(O(1)\\) space; when initializing the array nums, the program occupies \\(O(n)\\) space, hence the worst-case space complexity is \\(O(n)\\).
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n > 10:\n        nums = [0] * n  # O(n)\n
    void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector<int> b(10000);    // O(1)\n    if (n > 10)\n        vector<int> nums(n); // O(n)\n}\n
    void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n > 10)\n        int[] nums = new int[n]; // O(n)\n}\n
    void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n > 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n
    func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n > 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n
    func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n > 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n
    function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n > 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n
    function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n > 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n
    void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List<int> b = List.filled(10000, 0);  // O(1)\n  if (n > 10) {\n    List<int> nums = List.filled(n, 0); // O(n)\n  }\n}\n
    fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n > 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n
    void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n > 10)\n        int nums[n] = {0};   // O(n)\n}\n
    \n
    \n

    In recursive functions, stack frame space must be taken into count. Consider the following code:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    def function() -> int:\n    # Perform certain operations\n    return 0\n\ndef loop(n: int):\n    \"\"\"Loop O(1)\"\"\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"Recursion O(n)\"\"\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n
    int func() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n/* Recursion O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    int function() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        function();\n    }\n}\n/* Recursion O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    int Function() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i < n; i++) {\n        Function();\n    }\n}\n/* Recursion O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n
    func function() int {\n    // Perform certain operations\n    return 0\n}\n\n/* Cycle O(1) */\nfunc loop(n int) {\n    for i := 0; i < n; i++ {\n        function()\n    }\n}\n\n/* Recursion O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n
    @discardableResult\nfunc function() -> Int {\n    // Perform certain operations\n    return 0\n}\n\n/* Cycle O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..< n {\n        function()\n    }\n}\n\n/* Recursion O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n
    function constFunc() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nfunction loop(n) {\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n/* Recursion O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n
    function constFunc(): number {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n/* Recursion O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n
    int function() {\n  // Perform certain operations\n  return 0;\n}\n/* Cycle O(1) */\nvoid loop(int n) {\n  for (int i = 0; i < n; i++) {\n    function();\n  }\n}\n/* Recursion O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  return recur(n - 1);\n}\n
    fn function() -> i32 {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* Recursion O(n) */\nvoid recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n
    int func() {\n    // Perform certain operations\n    return 0;\n}\n/* Cycle O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n/* Recursion O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    \n
    \n

    The time complexity of both loop() and recur() functions is \\(O(n)\\), but their space complexities differ.

    • The loop() function calls function() \\(n\\) times in a loop, where each iteration's function() returns and releases its stack frame space, so the space complexity remains \\(O(1)\\).
    • The recursive function recur() will have \\(n\\) instances of unreturned recur() existing simultaneously during its execution, thus occupying \\(O(n)\\) stack frame space.
    "},{"location":"chapter_computational_complexity/space_complexity/#243-common-types","title":"2.4.3 \u00a0 Common Types","text":"

    Let the size of the input data be \\(n\\), the following chart displays common types of space complexities (arranged from low to high).

    \\[ \\begin{aligned} O(1) < O(\\log n) < O(n) < O(n^2) < O(2^n) \\newline \\text{Constant Order} < \\text{Logarithmic Order} < \\text{Linear Order} < \\text{Quadratic Order} < \\text{Exponential Order} \\end{aligned} \\]

    Figure 2-16 \u00a0 Common Types of Space Complexity

    "},{"location":"chapter_computational_complexity/space_complexity/#1-constant-order-o1","title":"1. \u00a0 Constant Order \\(O(1)\\)","text":"

    Constant order is common in constants, variables, objects that are independent of the size of input data \\(n\\).

    Note that memory occupied by initializing variables or calling functions in a loop, which is released upon entering the next cycle, does not accumulate over space, thus the space complexity remains \\(O(1)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def function() -> int:\n    \"\"\"\u51fd\u6570\"\"\"\n    # \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n\ndef constant(n: int):\n    \"\"\"\u5e38\u6570\u9636\"\"\"\n    # \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in range(n):\n        c = 0\n    # \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in range(n):\n        function()\n
    space_complexity.cpp
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const int a = 0;\n    int b = 0;\n    vector<int> nums(10000);\n    ListNode node(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n
    space_complexity.java
    /* \u51fd\u6570 */\nint function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        function();\n    }\n}\n
    space_complexity.cs
    /* \u51fd\u6570 */\nint Function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid Constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        Function();\n    }\n}\n
    space_complexity.go
    /* \u51fd\u6570 */\nfunc function() int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfunc spaceConstant(n int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    var c int\n    for i := 0; i < n; i++ {\n        c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for i := 0; i < n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n
    space_complexity.swift
    /* \u51fd\u6570 */\n@discardableResult\nfunc function() -> Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfunc constant(n: Int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in 0 ..< n {\n        let c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in 0 ..< n {\n        function()\n    }\n}\n
    space_complexity.js
    /* \u51fd\u6570 */\nfunction constFunc() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nfunction constant(n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        const c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n
    space_complexity.ts
    /* \u51fd\u6570 */\nfunction constFunc(): number {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nfunction constant(n: number): void {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        const c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n
    space_complexity.dart
    /* \u51fd\u6570 */\nint function() {\n  // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n  return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n  // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n  final int a = 0;\n  int b = 0;\n  List<int> nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n  for (var i = 0; i < n; i++) {\n    int c = 0;\n  }\n  // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n  for (var i = 0; i < n; i++) {\n    function();\n  }\n}\n
    space_complexity.rs
    /* \u51fd\u6570 */\nfn function() -> i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\n#[allow(unused)]\nfn constant(n: i32) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for i in 0..n {\n        let c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for i in 0..n {\n        function();\n    }\n}\n
    space_complexity.c
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n
    space_complexity.kt
    /* \u51fd\u6570 */\nfun function(): Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfun constant(n: Int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (i in 0..<n) {\n        val c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (i in 0..<n) {\n        function()\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{function}\n\n[class]{}-[func]{constant}\n
    space_complexity.zig
    // \u51fd\u6570\nfn function() i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n// \u5e38\u6570\u9636\nfn constant(n: i32) void {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a: i32 = 0;\n    var b: i32 = 0;\n    var nums = [_]i32{0}**10000;\n    var node = inc.ListNode(i32){.val = 0};\n    var i: i32 = 0;\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    while (i < n) : (i += 1) {\n        var c: i32 = 0;\n        _ = c;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    i = 0;\n    while (i < n) : (i += 1) {\n        _ = function();\n    }\n    _ = a;\n    _ = b;\n    _ = nums;\n    _ = node;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_computational_complexity/space_complexity/#2-linear-order-on","title":"2. \u00a0 Linear Order \\(O(n)\\)","text":"

    Linear order is common in arrays, linked lists, stacks, queues, etc., where the number of elements is proportional to \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def linear(n: int):\n    \"\"\"\u7ebf\u6027\u9636\"\"\"\n    # \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    nums = [0] * n\n    # \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\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\n    vector<int> nums(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    vector<ListNode> nodes;\n    for (int i = 0; i < n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    unordered_map<int, string> map;\n    for (int i = 0; i < n; i++) {\n        map[i] = to_string(i);\n    }\n}\n
    space_complexity.java
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    int[] nums = new int[n];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    List<ListNode> nodes = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    Map<Integer, String> map = new HashMap<>();\n    for (int i = 0; i < n; i++) {\n        map.put(i, String.valueOf(i));\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\n    int[] nums = new int[n];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    List<ListNode> nodes = [];\n    for (int i = 0; i < n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    Dictionary<int, string> map = [];\n    for (int i = 0; i < n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\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\n    var nodes []*node\n    for i := 0; i < n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    m := make(map[int]string, n)\n    for i := 0; i < n; i++ {\n        m[i] = strconv.Itoa(i)\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\n    let nums = Array(repeating: 0, count: n)\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let nodes = (0 ..< n).map { ListNode(x: $0) }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, \"\\($0)\") })\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\n    const nums = new Array(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const nodes = [];\n    for (let i = 0; i < n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const map = new Map();\n    for (let i = 0; i < n; i++) {\n        map.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\n    const nums = new Array(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const nodes: ListNode[] = [];\n    for (let i = 0; i < n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const map = new Map();\n    for (let i = 0; i < n; i++) {\n        map.set(i, i.toString());\n    }\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\n  List<int> nums = List.filled(n, 0);\n  // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n  List<ListNode> nodes = [];\n  for (var i = 0; i < n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n  Map<int, String> map = HashMap();\n  for (var i = 0; i < n; i++) {\n    map.putIfAbsent(i, () => i.toString());\n  }\n}\n
    space_complexity.rs
    /* \u7ebf\u6027\u9636 */\n#[allow(unused)]\nfn linear(n: i32) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut nums = vec![0; n as usize];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n
    space_complexity.c
    /* \u54c8\u5e0c\u8868 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n} HashTable;\n\n/* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i < n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // \u5185\u5b58\u91ca\u653e\n    for (int i = 0; i < n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    HashTable *h = NULL;\n    for (int i = 0; i < n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp->key = i;\n        tmp->val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // \u5185\u5b58\u91ca\u653e\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n
    space_complexity.kt
    /* \u7ebf\u6027\u9636 */\nfun linear(n: Int) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    val nums = Array(n) { 0 }\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    val nodes = mutableListOf<ListNode>()\n    for (i in 0..<n) {\n        nodes.add(ListNode(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    val map = mutableMapOf<Int, String>()\n    for (i in 0..<n) {\n        map[i] = i.toString()\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{linear}\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\n    var nums = [_]i32{0}**n;\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    var nodes = std.ArrayList(i32).init(std.heap.page_allocator);\n    defer nodes.deinit();\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        try nodes.append(i);\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    var map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator);\n    defer map.deinit();\n    var j: i32 = 0;\n    while (j < n) : (j += 1) {\n        const string = try std.fmt.allocPrint(std.heap.page_allocator, \"{d}\", .{j});\n        defer std.heap.page_allocator.free(string);\n        try map.put(i, string);\n    }\n    _ = nums;\n}\n
    Code Visualization

    Full Screen >

    As shown below, this function's recursive depth is \\(n\\), meaning there are \\(n\\) instances of unreturned linear_recur() function, using \\(O(n)\\) size of stack frame space:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def linear_recur(n: int):\n    \"\"\"\u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    print(\"\u9012\u5f52 n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n
    space_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    cout << \"\u9012\u5f52 n = \" << n << endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    System.out.println(\"\u9012\u5f52 n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"\u9012\u5f52 n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n
    space_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"\u9012\u5f52 n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n
    space_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc linearRecur(n: Int) {\n    print(\"\u9012\u5f52 n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n
    space_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n) {\n    console.log(`\u9012\u5f52 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n: number): void {\n    console.log(`\u9012\u5f52 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n  print('\u9012\u5f52 n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n
    space_complexity.rs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn linear_recur(n: i32) {\n    println!(\"\u9012\u5f52 n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n
    space_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    printf(\"\u9012\u5f52 n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.kt
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun linearRecur(n: Int) {\n    println(\"\u9012\u5f52 n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n
    space_complexity.rb
    [class]{}-[func]{linear_recur}\n
    space_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn linearRecur(comptime n: i32) void {\n    std.debug.print(\"\u9012\u5f52 n = {}\\n\", .{n});\n    if (n == 1) return;\n    linearRecur(n - 1);\n}\n
    Code Visualization

    Full Screen >

    Figure 2-17 \u00a0 Recursive Function Generating Linear Order Space Complexity

    "},{"location":"chapter_computational_complexity/space_complexity/#3-quadratic-order-on2","title":"3. \u00a0 Quadratic Order \\(O(n^2)\\)","text":"

    Quadratic order is common in matrices and graphs, where the number of elements is quadratic to \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def quadratic(n: int):\n    \"\"\"\u5e73\u65b9\u9636\"\"\"\n    # \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    num_matrix = [[0] * n for _ in range(n)]\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    vector<vector<int>> numMatrix;\n    for (int i = 0; i < n; i++) {\n        vector<int> tmp;\n        for (int j = 0; j < n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n
    space_complexity.java
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    int[][] numMatrix = new int[n][n];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    List<List<Integer>> numList = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        List<Integer> tmp = new ArrayList<>();\n        for (int j = 0; j < n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636 */\nvoid Quadratic(int n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    int[,] numMatrix = new int[n, n];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    List<List<int>> numList = [];\n    for (int i = 0; i < n; i++) {\n        List<int> tmp = [];\n        for (int j = 0; j < n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n
    space_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc spaceQuadratic(n int) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    numMatrix := make([][]int, n)\n    for i := 0; i < n; i++ {\n        numMatrix[i] = make([]int, n)\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\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() => Array(n).fill(null));\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numList = [];\n    for (let i = 0; i < n; i++) {\n        const tmp = [];\n        for (let j = 0; j < n; j++) {\n            tmp.push(0);\n        }\n        numList.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\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() => Array(n).fill(null));\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numList = [];\n    for (let i = 0; i < n; i++) {\n        const tmp = [];\n        for (let j = 0; j < n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n  // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n  List<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));\n  // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n  List<List<int>> numList = [];\n  for (var i = 0; i < n; i++) {\n    List<int> tmp = [];\n    for (int j = 0; j < n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n
    space_complexity.rs
    /* \u5e73\u65b9\u9636 */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.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\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i < n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j < n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // \u5185\u5b58\u91ca\u653e\n    for (int i = 0; i < n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n
    space_complexity.kt
    /* \u5e73\u65b9\u9636 */\nfun quadratic(n: Int) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    val numMatrix: Array<Array<Int>?> = arrayOfNulls(n)\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    val numList: MutableList<MutableList<Int>> = arrayListOf()\n    for (i in 0..<n) {\n        val tmp = mutableListOf<Int>()\n        for (j in 0..<n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{quadratic}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) !void {\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    var nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator);\n    defer nodes.deinit();\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        var tmp = std.ArrayList(i32).init(std.heap.page_allocator);\n        defer tmp.deinit();\n        var j: i32 = 0;\n        while (j < n) : (j += 1) {\n            try tmp.append(0);\n        }\n        try nodes.append(tmp);\n    }\n}\n
    Code Visualization

    Full Screen >

    As shown below, the recursive depth of this function is \\(n\\), and in each recursive call, an array is initialized with lengths \\(n\\), \\(n-1\\), \\(\\dots\\), \\(2\\), \\(1\\), averaging \\(n/2\\), thus overall occupying \\(O(n^2)\\) space:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def quadratic_recur(n: int) -> int:\n    \"\"\"\u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n <= 0:\n        return 0\n    # \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    vector<int> nums(n);\n    cout << \"\u9012\u5f52 n = \" << n << \" \u4e2d\u7684 nums \u957f\u5ea6 = \" << nums.size() << endl;\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint QuadraticRecur(int n) {\n    if (n <= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n
    space_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceQuadraticRecur(n int) int {\n    if n <= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n
    space_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\n@discardableResult\nfunc quadraticRecur(n: Int) -> Int {\n    if n <= 0 {\n        return 0\n    }\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"\u9012\u5f52 n = \\(n) \u4e2d\u7684 nums \u957f\u5ea6 = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n) {\n    if (n <= 0) return 0;\n    const nums = new Array(n);\n    console.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n: number): number {\n    if (n <= 0) return 0;\n    const nums = new Array(n);\n    console.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n  if (n <= 0) return 0;\n  List<int> nums = List.filled(n, 0);\n  print('\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n
    space_complexity.rs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn quadratic_recur(n: i32) -> i32 {\n    if n <= 0 {\n        return 0;\n    };\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n
    space_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n
    space_complexity.kt
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n <= 0)\n        return 0\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n
    space_complexity.rb
    [class]{}-[func]{quadratic_recur}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn quadraticRecur(comptime n: i32) i32 {\n    if (n <= 0) return 0;\n    var nums = [_]i32{0}**n;\n    std.debug.print(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\\n\", .{n, nums.len});\n    return quadraticRecur(n - 1);\n}\n
    Code Visualization

    Full Screen >

    Figure 2-18 \u00a0 Recursive Function Generating Quadratic Order Space Complexity

    "},{"location":"chapter_computational_complexity/space_complexity/#4-exponential-order-o2n","title":"4. \u00a0 Exponential Order \\(O(2^n)\\)","text":"

    Exponential order is common in binary trees. Observe the below image, a \"full binary tree\" with \\(n\\) levels has \\(2^n - 1\\) nodes, occupying \\(O(2^n)\\) space:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def build_tree(n: int) -> TreeNode | None:\n    \"\"\"\u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n
    space_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root->left = buildTree(n - 1);\n    root->right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.java
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n
    space_complexity.go
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n
    space_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n: Int) -> TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n
    space_complexity.js
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n
    space_complexity.rs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfn build_tree(n: i32) -> Option<Rc<RefCell<TreeNode>>> {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n
    space_complexity.c
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root->left = buildTree(n - 1);\n    root->right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.kt
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n
    space_complexity.rb
    [class]{}-[func]{build_tree}\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) {\n    if (n == 0) return null;\n    const root = try mem_allocator.create(inc.TreeNode(i32));\n    root.init(0);\n    root.left = try buildTree(mem_allocator, n - 1);\n    root.right = try buildTree(mem_allocator, n - 1);\n    return root;\n}\n
    Code Visualization

    Full Screen >

    Figure 2-19 \u00a0 Full Binary Tree Generating Exponential Order Space Complexity

    "},{"location":"chapter_computational_complexity/space_complexity/#5-logarithmic-order-olog-n","title":"5. \u00a0 Logarithmic Order \\(O(\\log n)\\)","text":"

    Logarithmic order is common in divide-and-conquer algorithms. For example, in merge sort, an array of length \\(n\\) is recursively divided in half each round, forming a recursion tree of height \\(\\log n\\), using \\(O(\\log n)\\) stack frame space.

    Another example is converting a number to a string. Given a positive integer \\(n\\), its number of digits is \\(\\log_{10} n + 1\\), corresponding to the length of the string, thus the space complexity is \\(O(\\log_{10} n + 1) = O(\\log n)\\).

    "},{"location":"chapter_computational_complexity/space_complexity/#244-balancing-time-and-space","title":"2.4.4 \u00a0 Balancing Time and Space","text":"

    Ideally, we aim for both time complexity and space complexity to be optimal. However, in practice, optimizing both simultaneously is often difficult.

    Lowering time complexity usually comes at the cost of increased space complexity, and vice versa. The approach of sacrificing memory space to improve algorithm speed is known as \"space-time tradeoff\"; the reverse is known as \"time-space tradeoff\".

    The choice depends on which aspect we value more. In most cases, time is more precious than space, so \"space-time tradeoff\" is often the more common strategy. Of course, controlling space complexity is also very important when dealing with large volumes of data.

    "},{"location":"chapter_computational_complexity/summary/","title":"2.5 \u00a0 Summary","text":""},{"location":"chapter_computational_complexity/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"

    Algorithm Efficiency Assessment

    • Time efficiency and space efficiency are the two main criteria for assessing the merits of an algorithm.
    • We can assess algorithm efficiency through actual testing, but it's challenging to eliminate the influence of the test environment, and it consumes substantial computational resources.
    • Complexity analysis can overcome the disadvantages of actual testing. Its results are applicable across all operating platforms and can reveal the efficiency of algorithms at different data scales.

    Time Complexity

    • Time complexity measures the trend of an algorithm's running time with the increase in data volume, effectively assessing algorithm efficiency. However, it can fail in certain cases, such as with small input data volumes or when time complexities are the same, making it challenging to precisely compare the efficiency of algorithms.
    • Worst-case time complexity is denoted using big O notation, representing the asymptotic upper bound, reflecting the growth level of the number of operations \\(T(n)\\) as \\(n\\) approaches infinity.
    • Calculating time complexity involves two steps: first counting the number of operations, then determining the asymptotic upper bound.
    • Common time complexities, arranged from low to high, include \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n \\log n)\\), \\(O(n^2)\\), \\(O(2^n)\\), and \\(O(n!)\\), among others.
    • The time complexity of some algorithms is not fixed and depends on the distribution of input data. Time complexities are divided into worst, best, and average cases. The best case is rarely used because input data generally needs to meet strict conditions to achieve the best case.
    • Average time complexity reflects the efficiency of an algorithm under random data inputs, closely resembling the algorithm's performance in actual applications. Calculating average time complexity requires accounting for the distribution of input data and the subsequent mathematical expectation.

    Space Complexity

    • Space complexity, similar to time complexity, measures the trend of memory space occupied by an algorithm with the increase in data volume.
    • The relevant memory space used during the algorithm's execution can be divided into input space, temporary space, and output space. Generally, input space is not included in space complexity calculations. Temporary space can be divided into temporary data, stack frame space, and instruction space, where stack frame space usually affects space complexity only in recursive functions.
    • We usually focus only on the worst-case space complexity, which means calculating the space complexity of the algorithm under the worst input data and at the worst moment of operation.
    • Common space complexities, arranged from low to high, include \\(O(1)\\), \\(O(\\log n)\\), \\(O(n)\\), \\(O(n^2)\\), and \\(O(2^n)\\), among others.
    "},{"location":"chapter_computational_complexity/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Is the space complexity of tail recursion \\(O(1)\\)?

    Theoretically, the space complexity of a tail-recursive function can be optimized to \\(O(1)\\). However, most programming languages (such as Java, Python, C++, Go, C#) do not support automatic optimization of tail recursion, so it's generally considered to have a space complexity of \\(O(n)\\).

    Q: What is the difference between the terms \"function\" and \"method\"?

    A \"function\" can be executed independently, with all parameters passed explicitly. A \"method\" is associated with an object and is implicitly passed to the object calling it, able to operate on the data contained within an instance of a class.

    Here are some examples from common programming languages:

    • C is a procedural programming language without object-oriented concepts, so it only has functions. However, we can simulate object-oriented programming by creating structures (struct), and functions associated with these structures are equivalent to methods in other programming languages.
    • Java and C# are object-oriented programming languages where code blocks (methods) are typically part of a class. Static methods behave like functions because they are bound to the class and cannot access specific instance variables.
    • C++ and Python support both procedural programming (functions) and object-oriented programming (methods).

    Q: Does the \"Common Types of Space Complexity\" figure reflect the absolute size of occupied space?

    No, the figure shows space complexities, which reflect growth trends, not the absolute size of the occupied space.

    If you take \\(n = 8\\), you might find that the values of each curve don't correspond to their functions. This is because each curve includes a constant term, intended to compress the value range into a visually comfortable range.

    In practice, since we usually don't know the \"constant term\" complexity of each method, it's generally not possible to choose the best solution for \\(n = 8\\) based solely on complexity. However, for \\(n = 8^5\\), it's much easier to choose, as the growth trend becomes dominant.

    "},{"location":"chapter_computational_complexity/time_complexity/","title":"2.3 \u00a0 Time Complexity","text":"

    Time complexity is a concept used to measure how the run time of an algorithm increases with the size of the input data. Understanding time complexity is crucial for accurately assessing the efficiency of an algorithm.

    1. Determining the Running Platform: This includes hardware configuration, programming language, system environment, etc., all of which can affect the efficiency of code execution.
    2. Evaluating the Run Time for Various Computational Operations: For instance, an addition operation + might take 1 ns, a multiplication operation * might take 10 ns, a print operation print() might take 5 ns, etc.
    3. Counting All the Computational Operations in the Code: Summing the execution times of all these operations gives the total run time.

    For example, consider the following code with an input size of \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    # Under an operating platform\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # Cycle n times\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n
    // Under a particular operating platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i < n; i++) {  // 1 ns , every round i++ is executed\n        cout << 0 << endl;         // 5 ns\n    }\n}\n
    // Under a particular operating platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i < n; i++) {  // 1 ns , every round i++ is executed\n        System.out.println(0);     // 5 ns\n    }\n}\n
    // Under a particular operating platform\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i < n; i++) {  // 1 ns , every round i++ is executed\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n
    // Under a particular operating platform\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // Loop n times\n    for i := 0; i < n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n
    // Under a particular operating platform\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // Loop n times\n    for _ in 0 ..< n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n
    // Under a particular operating platform\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // Loop n times\n    for(let i = 0; i < n; i++) { // 1 ns , every round i++ is executed\n        console.log(0); // 5 ns\n    }\n}\n
    // Under a particular operating platform\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // Loop n times\n    for(let i = 0; i < n; i++) { // 1 ns , every round i++ is executed\n        console.log(0); // 5 ns\n    }\n}\n
    // Under a particular operating platform\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // Loop n times\n  for (int i = 0; i < n; i++) { // 1 ns , every round i++ is executed\n    print(0); // 5 ns\n  }\n}\n
    // Under a particular operating platform\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // Loop n times\n    for _ in 0..n {     // 1 ns for each round i++\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n
    // Under a particular operating platform\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // Loop n times\n    for (int i = 0; i < n; i++) {   // 1 ns , every round i++ is executed\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n
    \n
    // Under a particular operating platform\nfn algorithm(n: usize) void {\n    var a: i32 = 2; // 1 ns\n    a += 1; // 1 ns\n    a *= 2; // 10 ns\n    // Loop n times\n    for (0..n) |_| { // 1 ns\n        std.debug.print(\"{}\\n\", .{0}); // 5 ns\n    }\n}\n

    Using the above method, the run time of the algorithm can be calculated as \\((6n + 12)\\) ns:

    \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\]

    However, in practice, counting the run time of an algorithm is neither practical nor reasonable. First, we don't want to tie the estimated time to the running platform, as algorithms need to run on various platforms. Second, it's challenging to know the run time for each type of operation, making the estimation process difficult.

    "},{"location":"chapter_computational_complexity/time_complexity/#231-assessing-time-growth-trend","title":"2.3.1 \u00a0 Assessing Time Growth Trend","text":"

    Time complexity analysis does not count the algorithm's run time, but rather the growth trend of the run time as the data volume increases.

    Let's understand this concept of \"time growth trend\" with an example. Assume the input data size is \\(n\\), and consider three algorithms A, B, and C:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    # Time complexity of algorithm A: constant order\ndef algorithm_A(n: int):\n    print(0)\n# Time complexity of algorithm B: linear order\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# Time complexity of algorithm C: constant order\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n
    // Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    cout << 0 << endl;\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        cout << 0 << endl;\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        cout << 0 << endl;\n    }\n}\n
    // Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        System.out.println(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        System.out.println(0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// Time complexity of algorithm B: linear order\nvoid AlgorithmB(int n) {\n    for (int i = 0; i < n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid AlgorithmC(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// Time complexity of algorithm B: linear order\nfunc algorithm_B(n int) {\n    for i := 0; i < n; i++ {\n        fmt.Println(0)\n    }\n}\n// Time complexity of algorithm C: constant order\nfunc algorithm_C(n int) {\n    for i := 0; i < 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n
    // Time complexity of algorithm A: constant order\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// Time complexity of algorithm B: linear order\nfunc algorithmB(n: Int) {\n    for _ in 0 ..< n {\n        print(0)\n    }\n}\n\n// Time complexity of algorithm C: constant order\nfunc algorithmC(n: Int) {\n    for _ in 0 ..< 1_000_000 {\n        print(0)\n    }\n}\n
    // Time complexity of algorithm A: constant order\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// Time complexity of algorithm B: linear order\nfunction algorithm_B(n) {\n    for (let i = 0; i < n; i++) {\n        console.log(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfunction algorithm_C(n) {\n    for (let i = 0; i < 1000000; i++) {\n        console.log(0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// Time complexity of algorithm B: linear order\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i < n; i++) {\n        console.log(0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i < 1000000; i++) {\n        console.log(0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nvoid algorithmA(int n) {\n  print(0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithmB(int n) {\n  for (int i = 0; i < n; i++) {\n    print(0);\n  }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithmC(int n) {\n  for (int i = 0; i < 1000000; i++) {\n    print(0);\n  }\n}\n
    // Time complexity of algorithm A: constant order\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// Time complexity of algorithm B: linear order\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// Time complexity of algorithm C: constant order\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n
    // Time complexity of algorithm A: constant order\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// Time complexity of algorithm B: linear order\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// Time complexity of algorithm C: constant order\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n
    \n
    // Time complexity of algorithm A: constant order\nfn algorithm_A(n: usize) void {\n    _ = n;\n    std.debug.print(\"{}\\n\", .{0});\n}\n// Time complexity of algorithm B: linear order\nfn algorithm_B(n: i32) void {\n    for (0..n) |_| {\n        std.debug.print(\"{}\\n\", .{0});\n    }\n}\n// Time complexity of algorithm C: constant order\nfn algorithm_C(n: i32) void {\n    _ = n;\n    for (0..1000000) |_| {\n        std.debug.print(\"{}\\n\", .{0});\n    }\n}\n

    The following figure shows the time complexities of these three algorithms.

    • Algorithm A has just one print operation, and its run time does not grow with \\(n\\). Its time complexity is considered \"constant order.\"
    • Algorithm B involves a print operation looping \\(n\\) times, and its run time grows linearly with \\(n\\). Its time complexity is \"linear order.\"
    • Algorithm C has a print operation looping 1,000,000 times. Although it takes a long time, it is independent of the input data size \\(n\\). Therefore, the time complexity of C is the same as A, which is \"constant order.\"

    Figure 2-7 \u00a0 Time Growth Trend of Algorithms A, B, and C

    Compared to directly counting the run time of an algorithm, what are the characteristics of time complexity analysis?

    • Time complexity effectively assesses algorithm efficiency. For instance, algorithm B has linearly growing run time, which is slower than algorithm A when \\(n > 1\\) and slower than C when \\(n > 1,000,000\\). In fact, as long as the input data size \\(n\\) is sufficiently large, a \"constant order\" complexity algorithm will always be better than a \"linear order\" one, demonstrating the essence of time growth trend.
    • Time complexity analysis is more straightforward. Obviously, the running platform and the types of computational operations are irrelevant to the trend of run time growth. Therefore, in time complexity analysis, we can simply treat the execution time of all computational operations as the same \"unit time,\" simplifying the \"computational operation run time count\" to a \"computational operation count.\" This significantly reduces the complexity of estimation.
    • Time complexity has its limitations. For example, although algorithms A and C have the same time complexity, their actual run times can be quite different. Similarly, even though algorithm B has a higher time complexity than C, it is clearly superior when the input data size \\(n\\) is small. In these cases, it's difficult to judge the efficiency of algorithms based solely on time complexity. Nonetheless, despite these issues, complexity analysis remains the most effective and commonly used method for evaluating algorithm efficiency.
    "},{"location":"chapter_computational_complexity/time_complexity/#232-asymptotic-upper-bound","title":"2.3.2 \u00a0 Asymptotic Upper Bound","text":"

    Consider a function with an input size of \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # Cycle n times\n    for i in range(n):  # +1\n        print(0)        # +1\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i < n; i++) { // +1 (execute i ++ every round)\n        cout << 0 << endl;    // +1\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i < n; i++) { // +1 (execute i ++ every round)\n        System.out.println(0);    // +1\n    }\n}\n
    void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i < n; i++) {   // +1 (execute i ++ every round)\n        Console.WriteLine(0);   // +1\n    }\n}\n
    func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // Loop n times\n    for i := 0; i < n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n
    func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // Loop n times\n    for _ in 0 ..< n { // +1\n        print(0) // +1\n    }\n}\n
    function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for(let i = 0; i < n; i++){ // +1 (execute i ++ every round)\n        console.log(0); // +1\n    }\n}\n
    function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for(let i = 0; i < n; i++){ // +1 (execute i ++ every round)\n        console.log(0); // +1\n    }\n}\n
    void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // Loop n times\n  for (int i = 0; i < n; i++) { // +1 (execute i ++ every round)\n    print(0); // +1\n  }\n}\n
    fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // Loop n times\n    for _ in 0..n { // +1 (execute i ++ every round)\n        println!(\"{}\", 0); // +1\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // Loop n times\n    for (int i = 0; i < n; i++) {   // +1 (execute i ++ every round)\n        printf(\"%d\", 0);            // +1\n    }\n} \n
    \n
    fn algorithm(n: usize) void {\n    var a: i32 = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // Loop n times\n    for (0..n) |_| { // +1 (execute i ++ every round)\n        std.debug.print(\"{}\\n\", .{0}); // +1\n    }\n}\n

    Given a function that represents the number of operations of an algorithm as a function of the input size \\(n\\), denoted as \\(T(n)\\), consider the following example:

    \\[ T(n) = 3 + 2n \\]

    Since \\(T(n)\\) is a linear function, its growth trend is linear, and therefore, its time complexity is of linear order, denoted as \\(O(n)\\). This mathematical notation, known as \"big-O notation,\" represents the \"asymptotic upper bound\" of the function \\(T(n)\\).

    In essence, time complexity analysis is about finding the asymptotic upper bound of the \"number of operations \\(T(n)\\)\". It has a precise mathematical definition.

    Asymptotic Upper Bound

    If there exist positive real numbers \\(c\\) and \\(n_0\\) such that for all \\(n > n_0\\), \\(T(n) \\leq c \\cdot f(n)\\), then \\(f(n)\\) is considered an asymptotic upper bound of \\(T(n)\\), denoted as \\(T(n) = O(f(n))\\).

    As illustrated below, calculating the asymptotic upper bound involves finding a function \\(f(n)\\) such that, as \\(n\\) approaches infinity, \\(T(n)\\) and \\(f(n)\\) have the same growth order, differing only by a constant factor \\(c\\).

    Figure 2-8 \u00a0 Asymptotic Upper Bound of a Function

    "},{"location":"chapter_computational_complexity/time_complexity/#233-calculation-method","title":"2.3.3 \u00a0 Calculation Method","text":"

    While the concept of asymptotic upper bound might seem mathematically dense, you don't need to fully grasp it right away. Let's first understand the method of calculation, which can be practiced and comprehended over time.

    Once \\(f(n)\\) is determined, we obtain the time complexity \\(O(f(n))\\). But how do we determine the asymptotic upper bound \\(f(n)\\)? This process generally involves two steps: counting the number of operations and determining the asymptotic upper bound.

    "},{"location":"chapter_computational_complexity/time_complexity/#1-step-1-counting-the-number-of-operations","title":"1. \u00a0 Step 1: Counting the Number of Operations","text":"

    This step involves going through the code line by line. However, due to the presence of the constant \\(c\\) in \\(c \\cdot f(n)\\), all coefficients and constant terms in \\(T(n)\\) can be ignored. This principle allows for simplification techniques in counting operations.

    1. Ignore constant terms in \\(T(n)\\), as they do not affect the time complexity being independent of \\(n\\).
    2. Omit all coefficients. For example, looping \\(2n\\), \\(5n + 1\\) times, etc., can be simplified to \\(n\\) times since the coefficient before \\(n\\) does not impact the time complexity.
    3. Use multiplication for nested loops. The total number of operations equals the product of the number of operations in each loop, applying the simplification techniques from points 1 and 2 for each loop level.

    Given a function, we can use these techniques to count operations:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    def algorithm(n: int):\n    a = 1      # +0 (trick 1)\n    a = a + n  # +0 (trick 1)\n    # +n (technique 2)\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n (technique 3)\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n
    void algorithm(int n) {\n    int a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (int i = 0; i < 5 * n + 1; i++) {\n        cout << 0 << endl;\n    }\n    // +n*n (technique 3)\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            cout << 0 << endl;\n        }\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (int i = 0; i < 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n (technique 3)\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n
    void Algorithm(int n) {\n    int a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (int i = 0; i < 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n (technique 3)\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n
    func algorithm(n int) {\n    a := 1     // +0 (trick 1)\n    a = a + n  // +0 (trick 1)\n    // +n (technique 2)\n    for i := 0; i < 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n (technique 3)\n    for i := 0; i < 2 * n; i++ {\n        for j := 0; j < n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n
    func algorithm(n: Int) {\n    var a = 1 // +0 (trick 1)\n    a = a + n // +0 (trick 1)\n    // +n (technique 2)\n    for _ in 0 ..< (5 * n + 1) {\n        print(0)\n    }\n    // +n*n (technique 3)\n    for _ in 0 ..< (2 * n) {\n        for _ in 0 ..< (n + 1) {\n            print(0)\n        }\n    }\n}\n
    function algorithm(n) {\n    let a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (let i = 0; i < 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (technique 3)\n    for (let i = 0; i < 2 * n; i++) {\n        for (let j = 0; j < n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n
    function algorithm(n: number): void {\n    let a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (let i = 0; i < 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n (technique 3)\n    for (let i = 0; i < 2 * n; i++) {\n        for (let j = 0; j < n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n
    void algorithm(int n) {\n  int a = 1; // +0 (trick 1)\n  a = a + n; // +0 (trick 1)\n  // +n (technique 2)\n  for (int i = 0; i < 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n (technique 3)\n  for (int i = 0; i < 2 * n; i++) {\n    for (int j = 0; j < n + 1; j++) {\n      print(0);\n    }\n  }\n}\n
    fn algorithm(n: i32) {\n    let mut a = 1;     // +0 (trick 1)\n    a = a + n;        // +0 (trick 1)\n\n    // +n (technique 2)\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n (technique 3)\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +0 (trick 1)\n    a = a + n;  // +0 (trick 1)\n    // +n (technique 2)\n    for (int i = 0; i < 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n (technique 3)\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n
    \n
    fn algorithm(n: usize) void {\n    var a: i32 = 1;     // +0 (trick 1)\n    a = a + @as(i32, @intCast(n));        // +0 (trick 1)\n\n    // +n (technique 2)\n    for(0..(5 * n + 1)) |_| {\n        std.debug.print(\"{}\\n\", .{0});\n    }\n\n    // +n*n (technique 3)\n    for(0..(2 * n)) |_| {\n        for(0..(n + 1)) |_| {\n            std.debug.print(\"{}\\n\", .{0});\n        }\n    }\n}\n

    The formula below shows the counting results before and after simplification, both leading to a time complexity of \\(O(n^2)\\):

    \\[ \\begin{aligned} T(n) & = 2n(n + 1) + (5n + 1) + 2 & \\text{Complete Count (-.-|||)} \\newline & = 2n^2 + 7n + 3 \\newline T(n) & = n^2 + n & \\text{Simplified Count (o.O)} \\end{aligned} \\]"},{"location":"chapter_computational_complexity/time_complexity/#2-step-2-determining-the-asymptotic-upper-bound","title":"2. \u00a0 Step 2: Determining the Asymptotic Upper Bound","text":"

    The time complexity is determined by the highest order term in \\(T(n)\\). This is because, as \\(n\\) approaches infinity, the highest order term dominates, rendering the influence of other terms negligible.

    The following table illustrates examples of different operation counts and their corresponding time complexities. Some exaggerated values are used to emphasize that coefficients cannot alter the order of growth. When \\(n\\) becomes very large, these constants become insignificant.

    Table: Time Complexity for Different Operation Counts

    Operation Count \\(T(n)\\) Time Complexity \\(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/#234-common-types-of-time-complexity","title":"2.3.4 \u00a0 Common Types of Time Complexity","text":"

    Let's consider the input data size as \\(n\\). The common types of time complexities are illustrated below, arranged from lowest to highest:

    \\[ \\begin{aligned} O(1) < O(\\log n) < O(n) < O(n \\log n) < O(n^2) < O(2^n) < O(n!) \\newline \\text{Constant Order} < \\text{Logarithmic Order} < \\text{Linear Order} < \\text{Linear-Logarithmic Order} < \\text{Quadratic Order} < \\text{Exponential Order} < \\text{Factorial Order} \\end{aligned} \\]

    Figure 2-9 \u00a0 Common Types of Time Complexity

    "},{"location":"chapter_computational_complexity/time_complexity/#1-constant-order-o1","title":"1. \u00a0 Constant Order \\(O(1)\\)","text":"

    Constant order means the number of operations is independent of the input data size \\(n\\). In the following function, although the number of operations size might be large, the time complexity remains \\(O(1)\\) as it's unrelated to \\(n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def constant(n: int) -> int:\n    \"\"\"\u5e38\u6570\u9636\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.java
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.cs
    /* \u5e38\u6570\u9636 */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.go
    /* \u5e38\u6570\u9636 */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i < size; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e38\u6570\u9636 */\nfunc constant(n: Int) -> Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..< size {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e38\u6570\u9636 */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i < size; i++) count++;\n    return count;\n}\n
    time_complexity.ts
    /* \u5e38\u6570\u9636 */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i < size; i++) count++;\n    return count;\n}\n
    time_complexity.dart
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i < size; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e38\u6570\u9636 */\nfn constant(n: i32) -> i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i < size; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e38\u6570\u9636 */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 10_0000\n    for (i in 0..<size)\n        count++\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{constant}\n
    time_complexity.zig
    // \u5e38\u6570\u9636\nfn constant(n: i32) i32 {\n    _ = n;\n    var count: i32 = 0;\n    const size: i32 = 100_000;\n    var i: i32 = 0;\n    while(i<size) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_computational_complexity/time_complexity/#2-linear-order-on","title":"2. \u00a0 Linear Order \\(O(n)\\)","text":"

    Linear order indicates the number of operations grows linearly with the input data size \\(n\\). Linear order commonly appears in single-loop structures:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def linear(n: int) -> int:\n    \"\"\"\u7ebf\u6027\u9636\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636 */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u9636 */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i < n; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636 */\nfunc linear(n: Int) -> Int {\n    var count = 0\n    for _ in 0 ..< n {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636 */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i < n; i++) count++;\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636 */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i < n; i++) count++;\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i < n; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u9636 */\nfn linear(n: i32) -> i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u9636 */\nfun linear(n: Int): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (i in 0..<n)\n        count++\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{linear}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\nfn linear(n: i32) i32 {\n    var count: i32 = 0;\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    Operations like array traversal and linked list traversal have a time complexity of \\(O(n)\\), where \\(n\\) is the length of the array or list:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def array_traversal(nums: list[int]) -> int:\n    \"\"\"\u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\"\"\"\n    count = 0\n    # \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for num in nums:\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(vector<int> &nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for range nums {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums: [Int]) -> Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (let i = 0; i < nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (let i = 0; i < nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(List<int> nums) {\n  int count = 0;\n  // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfn array_traversal(nums: &[i32]) -> i32 {\n    let mut count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{array_traversal}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\nfn arrayTraversal(nums: []i32) i32 {\n    var count: i32 = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (nums) |_| {\n        count += 1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    It's important to note that the input data size \\(n\\) should be determined based on the type of input data. For example, in the first example, \\(n\\) represents the input data size, while in the second example, the length of the array \\(n\\) is the data size.

    "},{"location":"chapter_computational_complexity/time_complexity/#3-quadratic-order-on2","title":"3. \u00a0 Quadratic Order \\(O(n^2)\\)","text":"

    Quadratic order means the number of operations grows quadratically with the input data size \\(n\\). Quadratic order typically appears in nested loops, where both the outer and inner loops have a time complexity of \\(O(n)\\), resulting in an overall complexity of \\(O(n^2)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def quadratic(n: int) -> int:\n    \"\"\"\u5e73\u65b9\u9636\"\"\"\n    count = 0\n    # \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636 */\nint Quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n int) int {\n    count := 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for i := 0; i < n; i++ {\n        for j := 0; j < n; j++ {\n            count++\n        }\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n: Int) -> Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for _ in 0 ..< n {\n        for _ in 0 ..< n {\n            count += 1\n        }\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n  int count = 0;\n  // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n  for (int i = 0; i < n; i++) {\n    for (int j = 0; j < n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e73\u65b9\u9636 */\nfn quadratic(n: i32) -> i32 {\n    let mut count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e73\u65b9\u9636 */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (i in 0..<n) {\n        for (j in 0..<n) {\n            count++\n        }\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{quadratic}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) i32 {\n    var count: i32 = 0;\n    var i: i32 = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    while (i < n) : (i += 1) {\n        var j: i32 = 0;\n        while (j < n) : (j += 1) {\n            count += 1;\n        }\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    The following image compares constant order, linear order, and quadratic order time complexities.

    Figure 2-10 \u00a0 Constant, Linear, and Quadratic Order Time Complexities

    For instance, in bubble sort, the outer loop runs \\(n - 1\\) times, and the inner loop runs \\(n-1\\), \\(n-2\\), ..., \\(2\\), \\(1\\) times, averaging \\(n / 2\\) times, resulting in a time complexity of \\(O((n - 1) n / 2) = O(n^2)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def bubble_sort(nums: list[int]) -> int:\n    \"\"\"\u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\"\"\"\n    count = 0  # \u8ba1\u6570\u5668\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j in range(i):\n            if nums[j] > nums[j + 1]:\n                # \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n    return count\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(vector<int> &nums) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int[] nums) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint BubbleSort(int[] nums) {\n    int count = 0;  // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums []int) int {\n    count := 0 // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j := 0; j < i; j++ {\n            if nums[j] > nums[j+1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums: inout [Int]) -> Int {\n    var count = 0 // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in nums.indices.dropFirst().reversed() {\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\n        for j in 0 ..< i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums) {\n    let count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(List<int> nums) {\n  int count = 0; // \u8ba1\u6570\u5668\n  // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n  for (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\n    for (var j = 0; j < i; j++) {\n      if (nums[j] > nums[j + 1]) {\n        // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n      }\n    }\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfn bubble_sort(nums: &mut [i32]) -> i32 {\n    let mut count = 0; // \u8ba1\u6570\u5668\n\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in (1..nums.len()).rev() {\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\n        for j in 0..i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (i in nums.size - 1 downTo 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\n        for (j in 0..<i) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j] = nums[j + 1].also { nums[j + 1] = nums[j] }\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{bubble_sort}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\nfn bubbleSort(nums: []i32) i32 {\n    var count: i32 = 0;  // \u8ba1\u6570\u5668 \n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    var i: i32 = @as(i32, @intCast(nums.len)) - 1;\n    while (i > 0) : (i -= 1) {\n        var 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\n        while (j < i) : (j += 1) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                var tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_computational_complexity/time_complexity/#4-exponential-order-o2n","title":"4. \u00a0 Exponential Order \\(O(2^n)\\)","text":"

    Biological \"cell division\" is a classic example of exponential order growth: starting with one cell, it becomes two after one division, four after two divisions, and so on, resulting in \\(2^n\\) cells after \\(n\\) divisions.

    The following image and code simulate the cell division process, with a time complexity of \\(O(2^n)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def exponential(n: int) -> int:\n    \"\"\"\u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\n    count = 0\n    base = 1\n    # \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.java
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i < n; i++ {\n        for j := 0; j < base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc exponential(n: Int) -> Int {\n    var count = 0\n    var base = 1\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..< n {\n        for _ in 0 ..< base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i < n; i++) {\n    for (var j = 0; j < base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n
    time_complexity.rs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfn exponential(n: i32) -> i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.kt
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfun exponential(n: Int): Int {\n    var count = 0\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    var base = 1\n    for (i in 0..<n) {\n        for (j in 0..<base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{exponential}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn exponential(n: i32) i32 {\n    var count: i32 = 0;\n    var bas: i32 = 1;\n    var i: i32 = 0;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    while (i < n) : (i += 1) {\n        var j: i32 = 0;\n        while (j < bas) : (j += 1) {\n            count += 1;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    Code Visualization

    Full Screen >

    Figure 2-11 \u00a0 Exponential Order Time Complexity

    In practice, exponential order often appears in recursive functions. For example, in the code below, it recursively splits into two halves, stopping after \\(n\\) divisions:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def exp_recur(n: int) -> int:\n    \"\"\"\u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.java
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return 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) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return 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 {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return 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 {\n    if (n === 1) return 1;\n    return 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) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.rs
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn exp_recur(n: i32) -> i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.kt
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n
    time_complexity.rb
    [class]{}-[func]{exp_recur}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn expRecur(n: i32) i32 {\n    if (n == 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    Code Visualization

    Full Screen >

    Exponential order growth is extremely rapid and is commonly seen in exhaustive search methods (brute force, backtracking, etc.). For large-scale problems, exponential order is unacceptable, often requiring dynamic programming or greedy algorithms as solutions.

    "},{"location":"chapter_computational_complexity/time_complexity/#5-logarithmic-order-olog-n","title":"5. \u00a0 Logarithmic Order \\(O(\\log n)\\)","text":"

    In contrast to exponential order, logarithmic order reflects situations where \"the size is halved each round.\" Given an input data size \\(n\\), since the size is halved each round, the number of iterations is \\(\\log_2 n\\), the inverse function of \\(2^n\\).

    The following image and code simulate the \"halving each round\" process, with a time complexity of \\(O(\\log_2 n)\\), commonly abbreviated as \\(O(\\log n)\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def logarithmic(n: int) -> int:\n    \"\"\"\u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\n    count = 0\n    while n > 1:\n        n = n / 2\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc logarithmic(n int) int {\n    count := 0\n    for n > 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc logarithmic(n: Int) -> Int {\n    var count = 0\n    var n = n\n    while n > 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n  int count = 0;\n  while (n > 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfn logarithmic(mut n: i32) -> i32 {\n    let mut count = 0;\n    while n > 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 > 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{logarithmic}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn logarithmic(n: i32) i32 {\n    var count: i32 = 0;\n    var n_var = n;\n    while (n_var > 1)\n    {\n        n_var = n_var / 2;\n        count +=1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    Figure 2-12 \u00a0 Logarithmic Order Time Complexity

    Like exponential order, logarithmic order also frequently appears in recursive functions. The code below forms a recursive tree of height \\(\\log_2 n\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def log_recur(n: int) -> int:\n    \"\"\"\u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n <= 1:\n        return 0\n    return log_recur(n / 2) + 1\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint LogRecur(int n) {\n    if (n <= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc logRecur(n int) int {\n    if n <= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc logRecur(n: Int) -> Int {\n    if n <= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n) {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n: number): number {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n  if (n <= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n
    time_complexity.rs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn log_recur(n: i32) -> i32 {\n    if n <= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.kt
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun logRecur(n: Int): Int {\n    if (n <= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n
    time_complexity.rb
    [class]{}-[func]{log_recur}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn logRecur(n: i32) i32 {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    Code Visualization

    Full Screen >

    Logarithmic order is typical in algorithms based on the divide-and-conquer strategy, embodying the \"split into many\" and \"simplify complex problems\" approach. It's slow-growing and is the most ideal time complexity after constant order.

    What is the base of \\(O(\\log n)\\)?

    Technically, \"splitting into \\(m\\)\" corresponds to a time complexity of \\(O(\\log_m n)\\). Using the logarithm base change formula, we can equate different logarithmic complexities:

    \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\]

    This means the base \\(m\\) can be changed without affecting the complexity. Therefore, we often omit the base \\(m\\) and simply denote logarithmic order as \\(O(\\log n)\\).

    "},{"location":"chapter_computational_complexity/time_complexity/#6-linear-logarithmic-order-on-log-n","title":"6. \u00a0 Linear-Logarithmic Order \\(O(n \\log n)\\)","text":"

    Linear-logarithmic order often appears in nested loops, with the complexities of the two loops being \\(O(\\log n)\\) and \\(O(n)\\) respectively. The related code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def linear_log_recur(n: int) -> int:\n    \"\"\"\u7ebf\u6027\u5bf9\u6570\u9636\"\"\"\n    if n <= 1:\n        return 1\n    count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    for _ in range(n):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint LinearLogRecur(int n) {\n    if (n <= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n int) int {\n    if n <= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i < n; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n: Int) -> Int {\n    if n <= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n) {\n    if (n <= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n: number): number {\n    if (n <= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n  if (n <= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i < n; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfn linear_log_recur(n: i32) -> i32 {\n    if n <= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n as i32 {\n        count += 1;\n    }\n    return count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfun linearLogRecur(n: Int): Int {\n    if (n <= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..<n.toInt()) {\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{linear_log_recur}\n
    time_complexity.zig
    // \u7ebf\u6027\u5bf9\u6570\u9636\nfn linearLogRecur(n: i32) i32 {\n    if (n <= 1) return 1;\n    var count: i32 = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    The image below demonstrates how linear-logarithmic order is generated. Each level of a binary tree has \\(n\\) operations, and the tree has \\(\\log_2 n + 1\\) levels, resulting in a time complexity of \\(O(n \\log n)\\).

    Figure 2-13 \u00a0 Linear-Logarithmic Order Time Complexity

    Mainstream sorting algorithms typically have a time complexity of \\(O(n \\log n)\\), such as quicksort, mergesort, and heapsort.

    "},{"location":"chapter_computational_complexity/time_complexity/#7-factorial-order-on","title":"7. \u00a0 Factorial Order \\(O(n!)\\)","text":"

    Factorial order corresponds to the mathematical problem of \"full permutation.\" Given \\(n\\) distinct elements, the total number of possible permutations is:

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

    Factorials are typically implemented using recursion. As shown in the image and code below, the first level splits into \\(n\\) branches, the second level into \\(n - 1\\) branches, and so on, stopping after the \\(n\\)th level:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def factorial_recur(n: int) -> int:\n    \"\"\"\u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n
    time_complexity.cpp
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for i := 0; i < n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n: Int) -> Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in 0 ..< n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n
    time_complexity.js
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (let i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (let i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n  for (var i = 0; i < n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn factorial_recur(n: i32) -> i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n
    time_complexity.c
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (i in 0..<n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{factorial_recur}\n
    time_complexity.zig
    // \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn factorialRecur(n: i32) i32 {\n    if (n == 0) return 1;\n    var count: i32 = 0;\n    var i: i32 = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    while (i < n) : (i += 1) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    Code Visualization

    Full Screen >

    Figure 2-14 \u00a0 Factorial Order Time Complexity

    Note that factorial order grows even faster than exponential order; it's unacceptable for larger \\(n\\) values.

    "},{"location":"chapter_computational_complexity/time_complexity/#235-worst-best-and-average-time-complexities","title":"2.3.5 \u00a0 Worst, Best, and Average Time Complexities","text":"

    The time efficiency of an algorithm is often not fixed but depends on the distribution of the input data. Assume we have an array nums of length \\(n\\), consisting of numbers from \\(1\\) to \\(n\\), each appearing only once, but in a randomly shuffled order. The task is to return the index of the element \\(1\\). We can draw the following conclusions:

    • When nums = [?, ?, ..., 1], that is, when the last element is \\(1\\), it requires a complete traversal of the array, achieving the worst-case time complexity of \\(O(n)\\).
    • When nums = [1, ?, ?, ...], that is, when the first element is \\(1\\), no matter the length of the array, no further traversal is needed, achieving the best-case time complexity of \\(\\Omega(1)\\).

    The \"worst-case time complexity\" corresponds to the asymptotic upper bound, denoted by the big \\(O\\) notation. Correspondingly, the \"best-case time complexity\" corresponds to the asymptotic lower bound, denoted by \\(\\Omega\\):

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    nums = [i for i in range(1, n + 1)]\n    # \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -> int:\n    \"\"\"\u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\"\"\"\n    for 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)\n        if nums[i] == 1:\n            return i\n    return -1\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) {\n    vector<int> nums(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u4f7f\u7528\u7cfb\u7edf\u65f6\u95f4\u751f\u6210\u968f\u673a\u79cd\u5b50\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(vector<int> &nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n
    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) {\n    Integer[] nums = new Integer[n];\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -> int[]\n    int[] res = new int[n];\n    for (int i = 0; i < n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int[] nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -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) {\n    int[] nums = new int[n];\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (int i = 0; i < nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint FindOne(int[] nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\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 {\n    nums := make([]int, n)\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for i := 0; i < n; i++ {\n        nums[i] = i + 1\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums []int) int {\n    for 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)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -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 }\n    var nums = Array(1 ... n)\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    nums.shuffle()\n    return nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums: [Int]) -> Int {\n    for 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)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -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) {\n    const nums = Array(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (let i = 0; i < n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums) {\n    for (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)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -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[] {\n    const nums = Array(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (let i = 0; i < n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums: number[]): number {\n    for (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)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -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) {\n  final nums = List.filled(n, 0);\n  // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i < n; i++) {\n    nums[i] = i + 1;\n  }\n  // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n  nums.shuffle();\n\n  return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(List<int> nums) {\n  for (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)\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n
    worst_best_time_complexity.rs
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfn random_numbers(n: i32) -> Vec<i32> {\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::<Vec<i32>>();\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    nums.shuffle(&mut thread_rng());\n    nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfn find_one(nums: &[i32]) -> Option<usize> {\n    for i in 0..nums.len() {\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)\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\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\u4e3a n \uff0c\u5143\u7d20\u7c7b\u578b\u4e3a int \uff09\n    int *nums = (int *)malloc(n * sizeof(int));\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (int i = n - 1; i > 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int *nums, int n) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n
    worst_best_time_complexity.kt
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfun randomNumbers(n: Int): Array<Int?> {\n    val nums = IntArray(n)\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (i in 0..<n) {\n        nums[i] = i + 1\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    val mutableList = nums.toMutableList()\n    mutableList.shuffle()\n    // Integer[] -> int[]\n    val res = arrayOfNulls<Int>(n)\n    for (i in 0..<n) {\n        res[i] = mutableList[i]\n    }\n    return res\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfun findOne(nums: Array<Int?>): Int {\n    for (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)\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n
    worst_best_time_complexity.rb
    [class]{}-[func]{random_numbers}\n\n[class]{}-[func]{find_one}\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\nfn randomNumbers(comptime n: usize) [n]i32 {\n    var nums: [n]i32 = undefined;\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (&nums, 0..) |*num, i| {\n        num.* = @as(i32, @intCast(i)) + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    const rand = std.crypto.random;\n    rand.shuffle(i32, &nums);\n    return nums;\n}\n\n// \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\nfn findOne(nums: []i32) i32 {\n    for (nums, 0..) |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)\n        if (num == 1) return @intCast(i);\n    }\n    return -1;\n}\n
    Code Visualization

    Full Screen >

    It's important to note that the best-case time complexity is rarely used in practice, as it is usually only achievable under very low probabilities and might be misleading. The worst-case time complexity is more practical as it provides a safety value for efficiency, allowing us to confidently use the algorithm.

    From the above example, it's clear that both the worst-case and best-case time complexities only occur under \"special data distributions,\" which may have a small probability of occurrence and may not accurately reflect the algorithm's run efficiency. In contrast, the average time complexity can reflect the algorithm's efficiency under random input data, denoted by the \\(\\Theta\\) notation.

    For some algorithms, we can simply estimate the average case under a random data distribution. For example, in the aforementioned example, since the input array is shuffled, the probability of element \\(1\\) appearing at any index is equal. Therefore, the average number of loops for the algorithm is half the length of the array \\(n / 2\\), giving an average time complexity of \\(\\Theta(n / 2) = \\Theta(n)\\).

    However, calculating the average time complexity for more complex algorithms can be quite difficult, as it's challenging to analyze the overall mathematical expectation under the data distribution. In such cases, we usually use the worst-case time complexity as the standard for judging the efficiency of the algorithm.

    Why is the \\(\\Theta\\) symbol rarely seen?

    Possibly because the \\(O\\) notation is more commonly spoken, it is often used to represent the average time complexity. However, strictly speaking, this practice is not accurate. In this book and other materials, if you encounter statements like \"average time complexity \\(O(n)\\)\", please understand it directly as \\(\\Theta(n)\\).

    "},{"location":"chapter_data_structure/","title":"Chapter 3. \u00a0 Data Structures","text":"

    Abstract

    Data structures serve as a robust and diverse framework.

    They offer a blueprint for the orderly organization of data, upon which algorithms come to life.

    "},{"location":"chapter_data_structure/#chapter-contents","title":"Chapter Contents","text":"
    • 3.1 \u00a0 Classification of Data Structures
    • 3.2 \u00a0 Fundamental Data Types
    • 3.3 \u00a0 Number Encoding *
    • 3.4 \u00a0 Character Encoding *
    • 3.5 \u00a0 Summary
    "},{"location":"chapter_data_structure/basic_data_types/","title":"3.2 \u00a0 Basic Data Types","text":"

    When discussing data in computers, various forms like text, images, videos, voice and 3D models comes to mind. Despite their different organizational forms, they are all composed of various basic data types.

    Basic data types are those that the CPU can directly operate on and are directly used in algorithms, mainly including the following.

    • Integer types: byte, short, int, long.
    • Floating-point types: float, double, used to represent decimals.
    • Character type: char, used to represent letters, punctuation, and even emojis in various languages.
    • Boolean type: bool, used to represent \"yes\" or \"no\" decisions.

    Basic data types are stored in computers in binary form. One binary digit is 1 bit. In most modern operating systems, 1 byte consists of 8 bits.

    The range of values for basic data types depends on the size of the space they occupy. Below, we take Java as an example.

    • The integer type byte occupies 1 byte = 8 bits and can represent \\(2^8\\) numbers.
    • The integer type int occupies 4 bytes = 32 bits and can represent \\(2^{32}\\) numbers.

    The following table lists the space occupied, value range, and default values of various basic data types in Java. While memorizing this table isn't necessary, having a general understanding of it and referencing it when required is recommended.

    Table 3-1 \u00a0 Space Occupied and Value Range of Basic Data Types

    Type Symbol Space Occupied Minimum Value Maximum Value Default Value Integer 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 Float float 4 bytes \\(1.175 \\times 10^{-38}\\) \\(3.403 \\times 10^{38}\\) \\(0.0\\text{f}\\) double 8 bytes \\(2.225 \\times 10^{-308}\\) \\(1.798 \\times 10^{308}\\) 0.0 Char char 2 bytes 0 \\(2^{16} - 1\\) 0 Boolean bool 1 byte \\(\\text{false}\\) \\(\\text{true}\\) \\(\\text{false}\\)

    Please note that the above table is specific to Java's basic data types. Every programming language has its own data type definitions, which might differ in space occupied, value ranges, and default values.

    • In Python, the integer type int can be of any size, limited only by available memory; the floating-point float is double precision 64-bit; there is no char type, as a single character is actually a string str of length 1.
    • C and C++ do not specify the size of basic data types, it varies with implementation and platform. The above table follows the LP64 data model, used for Unix 64-bit operating systems including Linux and macOS.
    • The size of char in C and C++ is 1 byte, while in most programming languages, it depends on the specific character encoding method, as detailed in the \"Character Encoding\" chapter.
    • Even though representing a boolean only requires 1 bit (0 or 1), it is usually stored in memory as 1 byte. This is because modern computer CPUs typically use 1 byte as the smallest addressable memory unit.

    So, what is the connection between basic data types and data structures? We know that data structures are ways to organize and store data in computers. The focus here is on \"structure\" rather than \"data\".

    If we want to represent \"a row of numbers\", we naturally think of using an array. This is because the linear structure of an array can represent the adjacency and the ordering of the numbers, but whether the stored content is an integer int, a decimal float, or a character char, is irrelevant to the \"data structure\".

    In other words, basic data types provide the \"content type\" of data, while data structures provide the \"way of organizing\" data. For example, in the following code, we use the same data structure (array) to store and represent different basic data types, including int, float, char, bool, etc.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    # Using various basic data types to initialize arrays\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# Python's characters are actually strings of length 1\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python's lists can freely store various basic data types and object references\ndata = [0, 0.0, 'a', False, ListNode(0)]\n
    // Using various basic data types to initialize arrays\nint numbers[5];\nfloat decimals[5];\nchar characters[5];\nbool bools[5];\n
    // Using various basic data types to initialize arrays\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nboolean[] bools = new boolean[5];\n
    // Using various basic data types to initialize arrays\nint[] numbers = new int[5];\nfloat[] decimals = new float[5];\nchar[] characters = new char[5];\nbool[] bools = new bool[5];\n
    // Using various basic data types to initialize arrays\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n
    // Using various basic data types to initialize arrays\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\n
    // JavaScript's arrays can freely store various basic data types and objects\nconst array = [0, 0.0, 'a', false];\n
    // Using various basic data types to initialize arrays\nconst numbers: number[] = [];\nconst characters: string[] = [];\nconst bools: boolean[] = [];\n
    // Using various basic data types to initialize arrays\nList<int> numbers = List.filled(5, 0);\nList<double> decimals = List.filled(5, 0.0);\nList<String> characters = List.filled(5, 'a');\nList<bool> bools = List.filled(5, false);\n
    // Using various basic data types to initialize arrays\nlet numbers: Vec<i32> = vec![0; 5];\nlet decimals: Vec<f32> = vec![0.0, 5];\nlet characters: Vec<char> = vec!['0'; 5];\nlet bools: Vec<bool> = vec![false; 5];\n
    // Using various basic data types to initialize arrays\nint numbers[10];\nfloat decimals[10];\nchar characters[10];\nbool bools[10];\n
    \n
    // Using various basic data types to initialize arrays\nvar numbers: [5]i32 = undefined;\nvar decimals: [5]f32 = undefined;\nvar characters: [5]u8 = undefined;\nvar bools: [5]bool = undefined;\n
    "},{"location":"chapter_data_structure/character_encoding/","title":"3.4 \u00a0 Character Encoding *","text":"

    In the computer system, all data is stored in binary form, and characters (represented by char) are no exception. To represent characters, we need to develop a \"character set\" that defines a one-to-one mapping between each character and binary numbers. With the character set, computers can convert binary numbers to characters by looking up the table.

    "},{"location":"chapter_data_structure/character_encoding/#341-ascii-character-set","title":"3.4.1 \u00a0 ASCII Character Set","text":"

    The \"ASCII code\" is one of the earliest character sets, officially known as the American Standard Code for Information Interchange. It uses 7 binary digits (the lower 7 bits of a byte) to represent a character, allowing for a maximum of 128 different characters. As shown in the Figure 3-6 , ASCII includes uppercase and lowercase English letters, numbers 0 ~ 9, various punctuation marks, and certain control characters (such as newline and tab).

    Figure 3-6 \u00a0 ASCII Code

    However, ASCII can only represent English characters. With the globalization of computers, a character set called \"EASCII\" was developed to represent more languages. It expands from the 7-bit structure of ASCII to 8 bits, enabling the representation of 256 characters.

    Globally, various region-specific EASCII character sets have been introduced. The first 128 characters of these sets are consistent with the ASCII, while the remaining 128 characters are defined differently to accommodate the requirements of different languages.

    "},{"location":"chapter_data_structure/character_encoding/#342-gbk-character-set","title":"3.4.2 \u00a0 GBK Character Set","text":"

    Later, it was found that EASCII still could not meet the character requirements of many languages. For instance, there are nearly a hundred thousand Chinese characters, with several thousand used regularly. In 1980, the Standardization Administration of China released the \"GB2312\" character set, which included 6763 Chinese characters, essentially fulfilling the computer processing needs for the Chinese language.

    However, GB2312 could not handle some rare and traditional characters. The \"GBK\" character set expands GB2312 and includes 21886 Chinese characters. In the GBK encoding scheme, ASCII characters are represented with one byte, while Chinese characters use two bytes.

    "},{"location":"chapter_data_structure/character_encoding/#343-unicode-character-set","title":"3.4.3 \u00a0 Unicode Character Set","text":"

    With the rapid evolution of computer technology and a plethora of character sets and encoding standards, numerous problems arose. On the one hand, these character sets generally only defined characters for specific languages and could not function properly in multilingual environments. On the other hand, the existence of multiple character set standards for the same language caused garbled text when information was exchanged between computers using different encoding standards.

    Researchers of that era thought: What if a comprehensive character set encompassing all global languages and symbols was developed? Wouldn't this resolve the issues associated with cross-linguistic environments and garbled text? Inspired by this idea, the extensive character set, Unicode, was born.

    \"Unicode\" is referred to as \"\u7edf\u4e00\u7801\" (Unified Code) in Chinese, theoretically capable of accommodating over a million characters. It aims to incorporate characters from all over the world into a single set, providing a universal character set for processing and displaying various languages and reducing the issues of garbled text due to different encoding standards.

    Since its release in 1991, Unicode has continually expanded to include new languages and characters. As of September 2022, Unicode contains 149,186 characters, including characters, symbols, and even emojis from various languages. In the vast Unicode character set, commonly used characters occupy 2 bytes, while some rare characters may occupy 3 or even 4 bytes.

    Unicode is a universal character set that assigns a number (called a \"code point\") to each character, but it does not specify how these character code points should be stored in a computer system. One might ask: How does a system interpret Unicode code points of varying lengths within a text? For example, given a 2-byte code, how does the system determine if it represents a single 2-byte character or two 1-byte characters?

    A straightforward solution to this problem is to store all characters as equal-length encodings. As shown in the Figure 3-7 , each character in \"Hello\" occupies 1 byte, while each character in \"\u7b97\u6cd5\" (algorithm) occupies 2 bytes. We could encode all characters in \"Hello \u7b97\u6cd5\" as 2 bytes by padding the higher bits with zeros. This method would enable the system to interpret a character every 2 bytes, recovering the content of the phrase.

    Figure 3-7 \u00a0 Unicode Encoding Example

    However, as ASCII has shown us, encoding English only requires 1 byte. Using the above approach would double the space occupied by English text compared to ASCII encoding, which is a waste of memory space. Therefore, a more efficient Unicode encoding method is needed.

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

    Currently, UTF-8 has become the most widely used Unicode encoding method internationally. It is a variable-length encoding, using 1 to 4 bytes to represent a character, depending on the complexity of the character. ASCII characters need only 1 byte, Latin and Greek letters require 2 bytes, commonly used Chinese characters need 3 bytes, and some other rare characters need 4 bytes.

    The encoding rules for UTF-8 are not complex and can be divided into two cases:

    • For 1-byte characters, set the highest bit to \\(0\\), and the remaining 7 bits to the Unicode code point. Notably, ASCII characters occupy the first 128 code points in the Unicode set. This means that UTF-8 encoding is backward compatible with ASCII. This implies that UTF-8 can be used to parse ancient ASCII text.
    • For characters of length \\(n\\) bytes (where \\(n > 1\\)), set the highest \\(n\\) bits of the first byte to \\(1\\), and the \\((n + 1)^{\\text{th}}\\) bit to \\(0\\); starting from the second byte, set the highest 2 bits of each byte to \\(10\\); the rest of the bits are used to fill the Unicode code point.

    The Figure 3-8 shows the UTF-8 encoding for \"Hello\u7b97\u6cd5\". It can be observed that since the highest \\(n\\) bits are set to \\(1\\), the system can determine the length of the character as \\(n\\) by counting the number of highest bits set to \\(1\\).

    But why set the highest 2 bits of the remaining bytes to \\(10\\)? Actually, this \\(10\\) serves as a kind of checksum. If the system starts parsing text from an incorrect byte, the \\(10\\) at the beginning of the byte can help the system quickly detect anomalies.

    The reason for using \\(10\\) as a checksum is that, under UTF-8 encoding rules, it's impossible for the highest two bits of a character to be \\(10\\). This can be proven by contradiction: If the highest two bits of a character are \\(10\\), it indicates that the character's length is \\(1\\), corresponding to ASCII. However, the highest bit of an ASCII character should be \\(0\\), which contradicts the assumption.

    Figure 3-8 \u00a0 UTF-8 Encoding Example

    Apart from UTF-8, other common encoding methods include:

    • UTF-16 Encoding: Uses 2 or 4 bytes to represent a character. All ASCII characters and commonly used non-English characters are represented with 2 bytes; a few characters require 4 bytes. For 2-byte characters, the UTF-16 encoding equals the Unicode code point.
    • UTF-32 Encoding: Every character uses 4 bytes. This means UTF-32 occupies more space than UTF-8 and UTF-16, especially for texts with a high proportion of ASCII characters.

    From the perspective of storage space, using UTF-8 to represent English characters is very efficient because it only requires 1 byte; using UTF-16 to encode some non-English characters (such as Chinese) can be more efficient because it only requires 2 bytes, while UTF-8 might need 3 bytes.

    From a compatibility perspective, UTF-8 is the most versatile, with many tools and libraries supporting UTF-8 as a priority.

    "},{"location":"chapter_data_structure/character_encoding/#345-character-encoding-in-programming-languages","title":"3.4.5 \u00a0 Character Encoding in Programming Languages","text":"

    Historically, many programming languages utilized fixed-length encodings such as UTF-16 or UTF-32 for processing strings during program execution. This allows strings to be handled as arrays, offering several advantages:

    • Random Access: Strings encoded in UTF-16 can be accessed randomly with ease. For UTF-8, which is a variable-length encoding, locating the \\(i^{th}\\) character requires traversing the string from the start to the \\(i^{th}\\) position, taking \\(O(n)\\) time.
    • Character Counting: Similar to random access, counting the number of characters in a UTF-16 encoded string is an \\(O(1)\\) operation. However, counting characters in a UTF-8 encoded string requires traversing the entire string.
    • String Operations: Many string operations like splitting, concatenating, inserting, and deleting are easier on UTF-16 encoded strings. These operations generally require additional computation on UTF-8 encoded strings to ensure the validity of the UTF-8 encoding.

    The design of character encoding schemes in programming languages is an interesting topic involving various factors:

    • Java\u2019s String type uses UTF-16 encoding, with each character occupying 2 bytes. This was based on the initial belief that 16 bits were sufficient to represent all possible characters and proven incorrect later. As the Unicode standard expanded beyond 16 bits, characters in Java may now be represented by a pair of 16-bit values, known as \u201csurrogate pairs.\u201d
    • JavaScript and TypeScript use UTF-16 encoding for similar reasons as Java. When JavaScript was first introduced by Netscape in 1995, Unicode was still in its early stages, and 16-bit encoding was sufficient to represent all Unicode characters.
    • C# uses UTF-16 encoding, largely because the .NET platform, designed by Microsoft, and many Microsoft technologies, including the Windows operating system, extensively use UTF-16 encoding.

    Due to the underestimation of character counts, these languages had to use \"surrogate pairs\" to represent Unicode characters exceeding 16 bits. This approach has its drawbacks: strings containing surrogate pairs may have characters occupying 2 or 4 bytes, losing the advantage of fixed-length encoding. Additionally, handling surrogate pairs adds complexity and debugging difficulty to programming.

    Addressing these challenges, some languages have adopted alternative encoding strategies:

    • Python\u2019s str type uses Unicode encoding with a flexible representation where the storage length of characters depends on the largest Unicode code point in the string. If all characters are ASCII, each character occupies 1 byte, 2 bytes for characters within the Basic Multilingual Plane (BMP), and 4 bytes for characters beyond the BMP.
    • Go\u2019s string type internally uses UTF-8 encoding. Go also provides the rune type for representing individual Unicode code points.
    • Rust\u2019s str and String types use UTF-8 encoding internally. Rust also offers the char type for individual Unicode code points.

    It\u2019s important to note that the above discussion pertains to how strings are stored in programming languages, which is different from how strings are stored in files or transmitted over networks. For file storage or network transmission, strings are usually encoded in UTF-8 format for optimal compatibility and space efficiency.

    "},{"location":"chapter_data_structure/classification_of_data_structure/","title":"3.1 \u00a0 Classification of Data Structures","text":"

    Common data structures include arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs. They can be classified into \"logical structure\" and \"physical structure\".

    "},{"location":"chapter_data_structure/classification_of_data_structure/#311-logical-structure-linear-and-non-linear","title":"3.1.1 \u00a0 Logical Structure: Linear and Non-Linear","text":"

    The logical structures reveal the logical relationships between data elements. In arrays and linked lists, data are arranged in a specific sequence, demonstrating the linear relationship between data; while in trees, data are arranged hierarchically from the top down, showing the derived relationship between \"ancestors\" and \"descendants\"; and graphs are composed of nodes and edges, reflecting the intricate network relationship.

    As shown in the Figure 3-1 , logical structures can be divided into two major categories: \"linear\" and \"non-linear\". Linear structures are more intuitive, indicating data is arranged linearly in logical relationships; non-linear structures, conversely, are arranged non-linearly.

    • Linear Data Structures: Arrays, Linked Lists, Stacks, Queues, Hash Tables.
    • Non-Linear Data Structures: Trees, Heaps, Graphs, Hash Tables.

    Figure 3-1 \u00a0 Linear and Non-Linear Data Structures

    Non-linear data structures can be further divided into tree structures and network structures.

    • Linear Structures: Arrays, linked lists, queues, stacks, and hash tables, where elements have a one-to-one sequential relationship.
    • Tree Structures: Trees, Heaps, Hash Tables, where elements have a one-to-many relationship.
    • Network Structures: Graphs, where elements have a many-to-many relationships.
    "},{"location":"chapter_data_structure/classification_of_data_structure/#312-physical-structure-contiguous-and-dispersed","title":"3.1.2 \u00a0 Physical Structure: Contiguous and Dispersed","text":"

    During the execution of an algorithm, the data being processed is stored in memory. The Figure 3-2 shows a computer memory stick where each black square is a physical memory space. We can think of memory as a vast Excel spreadsheet, with each cell capable of storing a certain amount of data.

    The system accesses the data at the target location by means of a memory address. As shown in the Figure 3-2 , the computer assigns a unique identifier to each cell in the table according to specific rules, ensuring that each memory space has a unique memory address. With these addresses, the program can access the data stored in memory.

    Figure 3-2 \u00a0 Memory Stick, Memory Spaces, Memory Addresses

    Tip

    It's worth noting that comparing memory to an Excel spreadsheet is a simplified analogy. The actual working mechanism of memory is more complex, involving concepts like address space, memory management, cache mechanisms, virtual memory, and physical memory.

    Memory is a shared resource for all programs. When a block of memory is occupied by one program, it cannot be simultaneously used by other programs. Therefore, considering memory resources is crucial in designing data structures and algorithms. For instance, the algorithm's peak memory usage should not exceed the remaining free memory of the system; if there is a lack of contiguous memory blocks, then the data structure chosen must be able to be stored in non-contiguous memory blocks.

    As illustrated in the Figure 3-3 , the physical structure reflects the way data is stored in computer memory and it can be divided into contiguous space storage (arrays) and non-contiguous space storage (linked lists). The two types of physical structures exhibit complementary characteristics in terms of time efficiency and space efficiency.

    Figure 3-3 \u00a0 Contiguous Space Storage and Dispersed Space Storage

    It is worth noting that all data structures are implemented based on arrays, linked lists, or a combination of both. For example, stacks and queues can be implemented using either arrays or linked lists; while implementations of hash tables may involve both arrays and linked lists. - Array-based implementations: Stacks, Queues, Hash Tables, Trees, Heaps, Graphs, Matrices, Tensors (arrays with dimensions \\(\\geq 3\\)). - Linked-list-based implementations: Stacks, Queues, Hash Tables, Trees, Heaps, Graphs, etc.

    Data structures implemented based on arrays are also called \u201cStatic Data Structures,\u201d meaning their length cannot be changed after initialization. Conversely, those based on linked lists are called \u201cDynamic Data Structures,\u201d which can still adjust their size during program execution.

    Tip

    If you find it challenging to comprehend the physical structure, it is recommended that you read the next chapter, \"Arrays and Linked Lists,\" and revisit this section later.

    "},{"location":"chapter_data_structure/number_encoding/","title":"3.3 \u00a0 Number Encoding *","text":"

    Note

    In this book, chapters marked with an asterisk '*' are optional readings. If you are short on time or find them challenging, you may skip these initially and return to them after completing the essential chapters.

    "},{"location":"chapter_data_structure/number_encoding/#331-integer-encoding","title":"3.3.1 \u00a0 Integer Encoding","text":"

    In the table from the previous section, we observed that all integer types can represent one more negative number than positive numbers, such as the byte range of \\([-128, 127]\\). This phenomenon seems counterintuitive, and its underlying reason involves knowledge of sign-magnitude, one's complement, and two's complement encoding.

    Firstly, it's important to note that numbers are stored in computers using the two's complement form. Before analyzing why this is the case, let's define these three encoding methods:

    • Sign-magnitude: The highest bit of a binary representation of a number is considered the sign bit, where \\(0\\) represents a positive number and \\(1\\) represents a negative number. The remaining bits represent the value of the number.
    • One's complement: The one's complement of a positive number is the same as its sign-magnitude. For negative numbers, it's obtained by inverting all bits except the sign bit.
    • Two's complement: The two's complement of a positive number is the same as its sign-magnitude. For negative numbers, it's obtained by adding \\(1\\) to their one's complement.

    The following diagram illustrates the conversions among sign-magnitude, one's complement, and two's complement:

    Figure 3-4 \u00a0 Conversions between Sign-Magnitude, One's Complement, and Two's Complement

    Although sign-magnitude is the most intuitive, it has limitations. For one, negative numbers in sign-magnitude cannot be directly used in calculations. For example, in sign-magnitude, calculating \\(1 + (-2)\\) results in \\(-3\\), which is incorrect.

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

    To address this, computers introduced the one's complement. If we convert to one's complement and calculate \\(1 + (-2)\\), then convert the result back to sign-magnitude, we get the correct result of \\(-1\\).

    \\[ \\begin{aligned} & 1 + (-2) \\newline & \\rightarrow 0000 \\; 0001 \\; \\text{(Sign-magnitude)} + 1000 \\; 0010 \\; \\text{(Sign-magnitude)} \\newline & = 0000 \\; 0001 \\; \\text{(One's complement)} + 1111 \\; 1101 \\; \\text{(One's complement)} \\newline & = 1111 \\; 1110 \\; \\text{(One's complement)} \\newline & = 1000 \\; 0001 \\; \\text{(Sign-magnitude)} \\newline & \\rightarrow -1 \\end{aligned} \\]

    Additionally, there are two representations of zero in sign-magnitude: \\(+0\\) and \\(-0\\). This means two different binary encodings for zero, which could lead to ambiguity. For example, in conditional checks, not differentiating between positive and negative zero might result in incorrect outcomes. Addressing this ambiguity would require additional checks, potentially reducing computational efficiency.

    \\[ \\begin{aligned} +0 & \\rightarrow 0000 \\; 0000 \\newline -0 & \\rightarrow 1000 \\; 0000 \\end{aligned} \\]

    Like sign-magnitude, one's complement also suffers from the positive and negative zero ambiguity. Therefore, computers further introduced the two's complement. Let's observe the conversion process for negative zero in sign-magnitude, one's complement, and two's complement:

    \\[ \\begin{aligned} -0 \\rightarrow \\; & 1000 \\; 0000 \\; \\text{(Sign-magnitude)} \\newline = \\; & 1111 \\; 1111 \\; \\text{(One's complement)} \\newline = 1 \\; & 0000 \\; 0000 \\; \\text{(Two's complement)} \\newline \\end{aligned} \\]

    Adding \\(1\\) to the one's complement of negative zero produces a carry, but with byte length being only 8 bits, the carried-over \\(1\\) to the 9th bit is discarded. Therefore, the two's complement of negative zero is \\(0000 \\; 0000\\), the same as positive zero, thus resolving the ambiguity.

    One last puzzle is the \\([-128, 127]\\) range for byte, with an additional negative number, \\(-128\\). We observe that for the interval \\([-127, +127]\\), all integers have corresponding sign-magnitude, one's complement, and two's complement, allowing for mutual conversion between them.

    However, the two's complement \\(1000 \\; 0000\\) is an exception without a corresponding sign-magnitude. According to the conversion method, its sign-magnitude would be \\(0000 \\; 0000\\), indicating zero. This presents a contradiction because its two's complement should represent itself. Computers designate this special two's complement \\(1000 \\; 0000\\) as representing \\(-128\\). In fact, the calculation of \\((-1) + (-127)\\) in two's complement results in \\(-128\\).

    \\[ \\begin{aligned} & (-127) + (-1) \\newline & \\rightarrow 1111 \\; 1111 \\; \\text{(Sign-magnitude)} + 1000 \\; 0001 \\; \\text{(Sign-magnitude)} \\newline & = 1000 \\; 0000 \\; \\text{(One's complement)} + 1111 \\; 1110 \\; \\text{(One's complement)} \\newline & = 1000 \\; 0001 \\; \\text{(Two's complement)} + 1111 \\; 1111 \\; \\text{(Two's complement)} \\newline & = 1000 \\; 0000 \\; \\text{(Two's complement)} \\newline & \\rightarrow -128 \\end{aligned} \\]

    As you might have noticed, all these calculations are additions, hinting at an important fact: computers' internal hardware circuits are primarily designed around addition operations. This is because addition is simpler to implement in hardware compared to other operations like multiplication, division, and subtraction, allowing for easier parallelization and faster computation.

    It's important to note that this doesn't mean computers can only perform addition. By combining addition with basic logical operations, computers can execute a variety of other mathematical operations. For example, the subtraction \\(a - b\\) can be translated into \\(a + (-b)\\); multiplication and division can be translated into multiple additions or subtractions.

    We can now summarize the reason for using two's complement in computers: with two's complement representation, computers can use the same circuits and operations to handle both positive and negative number addition, eliminating the need for special hardware circuits for subtraction and avoiding the ambiguity of positive and negative zero. This greatly simplifies hardware design and enhances computational efficiency.

    The design of two's complement is quite ingenious, and due to space constraints, we'll stop here. Interested readers are encouraged to explore further.

    "},{"location":"chapter_data_structure/number_encoding/#332-floating-point-number-encoding","title":"3.3.2 \u00a0 Floating-Point Number Encoding","text":"

    You might have noticed something intriguing: despite having the same length of 4 bytes, why does a float have a much larger range of values compared to an int? This seems counterintuitive, as one would expect the range to shrink for float since it needs to represent fractions.

    In fact, this is due to the different representation method used by floating-point numbers (float). Let's consider a 32-bit binary number as:

    \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\]

    According to the IEEE 754 standard, a 32-bit float consists of the following three parts:

    • Sign bit \\(\\mathrm{S}\\): Occupies 1 bit, corresponding to \\(b_{31}\\).
    • Exponent bit \\(\\mathrm{E}\\): Occupies 8 bits, corresponding to \\(b_{30} b_{29} \\ldots b_{23}\\).
    • Fraction bit \\(\\mathrm{N}\\): Occupies 23 bits, corresponding to \\(b_{22} b_{21} \\ldots b_0\\).

    The value of a binary float number is calculated as:

    \\[ \\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 \\]

    Converted to a decimal formula, this becomes:

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

    The range of each component is:

    \\[ \\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} \\times 2^{-i}) \\subset [1, 2 - 2^{-23}] \\end{aligned} \\]

    Figure 3-5 \u00a0 Example Calculation of a float in IEEE 754 Standard

    Observing the diagram, given an example data \\(\\mathrm{S} = 0\\), \\(\\mathrm{E} = 124\\), \\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\), we have:

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

    Now we can answer the initial question: The representation of float includes an exponent bit, leading to a much larger range than int. Based on the above calculation, the maximum positive number representable by float is approximately \\(2^{254 - 127} \\times (2 - 2^{-23}) \\approx 3.4 \\times 10^{38}\\), and the minimum negative number is obtained by switching the sign bit.

    However, the trade-off for float's expanded range is a sacrifice in precision. The integer type int uses all 32 bits to represent the number, with values evenly distributed; but due to the exponent bit, the larger the value of a float, the greater the difference between adjacent numbers.

    As shown in the Table 3-2 , exponent bits \\(E = 0\\) and \\(E = 255\\) have special meanings, used to represent zero, infinity, \\(\\mathrm{NaN}\\), etc.

    Table 3-2 \u00a0 Meaning of Exponent Bits

    Exponent Bit E Fraction Bit \\(\\mathrm{N} = 0\\) Fraction Bit \\(\\mathrm{N} \\ne 0\\) Calculation Formula \\(0\\) \\(\\pm 0\\) Subnormal Numbers \\((-1)^{\\mathrm{S}} \\times 2^{-126} \\times (0.\\mathrm{N})\\) \\(1, 2, \\dots, 254\\) Normal Numbers Normal Numbers \\((-1)^{\\mathrm{S}} \\times 2^{(\\mathrm{E} -127)} \\times (1.\\mathrm{N})\\) \\(255\\) \\(\\pm \\infty\\) \\(\\mathrm{NaN}\\)

    It's worth noting that subnormal numbers significantly improve the precision of floating-point numbers. The smallest positive normal number is \\(2^{-126}\\), and the smallest positive subnormal number is \\(2^{-126} \\times 2^{-23}\\).

    Double-precision double also uses a similar representation method to float, which is not elaborated here for brevity.

    "},{"location":"chapter_data_structure/summary/","title":"3.5 \u00a0 Summary","text":""},{"location":"chapter_data_structure/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"
    • Data structures can be categorized from two perspectives: logical structure and physical structure. Logical structure describes the logical relationships between data elements, while physical structure describes how data is stored in computer memory.
    • Common logical structures include linear, tree-like, and network structures. We generally classify data structures into linear (arrays, linked lists, stacks, queues) and non-linear (trees, graphs, heaps) based on their logical structure. The implementation of hash tables may involve both linear and non-linear data structures.
    • When a program runs, data is stored in computer memory. Each memory space has a corresponding memory address, and the program accesses data through these addresses.
    • Physical structures are primarily divided into contiguous space storage (arrays) and dispersed space storage (linked lists). All data structures are implemented using arrays, linked lists, or a combination of both.
    • Basic data types in computers include integers (byte, short, int, long), floating-point numbers (float, double), characters (char), and booleans (boolean). Their range depends on the size of the space occupied and the representation method.
    • Original code, complement code, and two's complement code are three methods of encoding numbers in computers, and they can be converted into each other. The highest bit of the original code of an integer is the sign bit, and the remaining bits represent the value of the number.
    • Integers are stored in computers in the form of two's complement. In this representation, the computer can treat the addition of positive and negative numbers uniformly, without the need for special hardware circuits for subtraction, and there is no ambiguity of positive and negative zero.
    • The encoding of floating-point numbers consists of 1 sign bit, 8 exponent bits, and 23 fraction bits. Due to the presence of the exponent bit, the range of floating-point numbers is much greater than that of integers, but at the cost of sacrificing precision.
    • ASCII is the earliest English character set, 1 byte in length, and includes 127 characters. The GBK character set is a commonly used Chinese character set, including more than 20,000 Chinese characters. Unicode strives to provide a complete character set standard, including characters from various languages worldwide, thus solving the problem of garbled characters caused by inconsistent character encoding methods.
    • UTF-8 is the most popular Unicode encoding method, with excellent universality. It is a variable-length encoding method with good scalability and effectively improves the efficiency of space usage. UTF-16 and UTF-32 are fixed-length encoding methods. When encoding Chinese characters, UTF-16 occupies less space than UTF-8. Programming languages like Java and C# use UTF-16 encoding by default.
    "},{"location":"chapter_data_structure/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Why does a hash table contain both linear and non-linear data structures?

    The underlying structure of a hash table is an array. To resolve hash collisions, we may use \"chaining\": each bucket in the array points to a linked list, which, when exceeding a certain threshold, might be transformed into a tree (usually a red-black tree). From a storage perspective, the foundation of a hash table is an array, where each bucket slot might contain a value, a linked list, or a tree. Therefore, hash tables may contain both linear data structures (arrays, linked lists) and non-linear data structures (trees).

    Q: Is the length of the char type 1 byte?

    The length of the char type is determined by the encoding method used by the programming language. For example, Java, JavaScript, TypeScript, and C# all use UTF-16 encoding (to save Unicode code points), so the length of the char type is 2 bytes.

    Q: Is there ambiguity in calling data structures based on arrays \"static data structures\"? Because operations like push and pop on stacks are \"dynamic\".

    While stacks indeed allow for dynamic data operations, the data structure itself remains \"static\" (with unchangeable length). Even though data structures based on arrays can dynamically add or remove elements, their capacity is fixed. If the data volume exceeds the pre-allocated size, a new, larger array needs to be created, and the contents of the old array copied into it.

    Q: When building stacks (queues) without specifying their size, why are they considered \"static data structures\"?

    In high-level programming languages, we don't need to manually specify the initial capacity of stacks (queues); this task is automatically handled internally by the class. For example, the initial capacity of Java's ArrayList is usually 10. Furthermore, the expansion operation is also implemented automatically. See the subsequent \"List\" chapter for details.

    "},{"location":"chapter_graph/","title":"Chapter 9. \u00a0 Graph","text":"

    Abstract

    In the journey of life, we are like individual nodes, connected by countless invisible edges.

    Every encountering and parting leaves a unique mark on this vast network graph.

    "},{"location":"chapter_graph/#chapter-contents","title":"Chapter Contents","text":"
    • 9.1 \u00a0 Graph
    • 9.2 \u00a0 Basic Graph Operations
    • 9.3 \u00a0 Graph Traversal
    • 9.4 \u00a0 Summary
    "},{"location":"chapter_graph/graph/","title":"9.1 \u00a0 Graph","text":"

    A \"graph\" is a type of nonlinear data structure, consisting of \"vertices\" and \"edges\". A graph \\(G\\) can be abstractly represented as a collection of a set of vertices \\(V\\) and a set of edges \\(E\\). The following example shows a graph containing 5 vertices and 7 edges.

    \\[ \\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} \\]

    If vertices are viewed as nodes and edges as references (pointers) connecting the nodes, graphs can be seen as a data structure that extends from linked lists. As shown below, compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) are more complex due to their higher degree of freedom.

    Figure 9-1 \u00a0 Relationship between linked lists, trees, and graphs

    "},{"location":"chapter_graph/graph/#911-common-types-of-graphs","title":"9.1.1 \u00a0 Common types of graphs","text":"

    Based on whether edges have direction, graphs can be divided into \"undirected graphs\" and \"directed graphs\", as shown below.

    • In undirected graphs, edges represent a \"bidirectional\" connection between two vertices, for example, the \"friendship\" in WeChat or QQ.
    • In directed graphs, edges have directionality, that is, the edges \\(A \\rightarrow B\\) and \\(A \\leftarrow B\\) are independent of each other, for example, the \"follow\" and \"be followed\" relationship on Weibo or TikTok.

    Figure 9-2 \u00a0 Directed and undirected graphs

    Based on whether all vertices are connected, graphs can be divided into \"connected graphs\" and \"disconnected graphs\", as shown below.

    • For connected graphs, it is possible to reach any other vertex starting from a certain vertex.
    • For disconnected graphs, there is at least one vertex that cannot be reached from a certain starting vertex.

    Figure 9-3 \u00a0 Connected and disconnected graphs

    We can also add a \"weight\" variable to edges, resulting in \"weighted graphs\" as shown below. For example, in mobile games like \"Honor of Kings\", the system calculates the \"closeness\" between players based on shared gaming time, and this closeness network can be represented with a weighted graph.

    Figure 9-4 \u00a0 Weighted and unweighted graphs

    Graph data structures include the following commonly used terms.

    • \"Adjacency\": When there is an edge connecting two vertices, these two vertices are said to be \"adjacent\". In the above figure, the adjacent vertices of vertex 1 are vertices 2, 3, and 5.
    • \"Path\": The sequence of edges passed from vertex A to vertex B is called a \"path\" from A to B. In the above figure, the edge sequence 1-5-2-4 is a path from vertex 1 to vertex 4.
    • \"Degree\": The number of edges a vertex has. For directed graphs, \"in-degree\" refers to how many edges point to the vertex, and \"out-degree\" refers to how many edges point out from the vertex.
    "},{"location":"chapter_graph/graph/#912-representation-of-graphs","title":"9.1.2 \u00a0 Representation of graphs","text":"

    Common representations of graphs include \"adjacency matrices\" and \"adjacency lists\". The following examples use undirected graphs.

    "},{"location":"chapter_graph/graph/#1-adjacency-matrix","title":"1. \u00a0 Adjacency matrix","text":"

    Let the number of vertices in the graph be \\(n\\), the \"adjacency matrix\" uses an \\(n \\times n\\) matrix to represent the graph, where each row (column) represents a vertex, and the matrix elements represent edges, with \\(1\\) or \\(0\\) indicating whether there is an edge between two vertices.

    As shown below, let the adjacency matrix be \\(M\\), and the list of vertices be \\(V\\), then the matrix element \\(M[i, j] = 1\\) indicates there is an edge between vertex \\(V[i]\\) and vertex \\(V[j]\\), conversely \\(M[i, j] = 0\\) indicates there is no edge between the two vertices.

    Figure 9-5 \u00a0 Representation of a graph with an adjacency matrix

    Adjacency matrices have the following characteristics.

    • A vertex cannot be connected to itself, so the elements on the main diagonal of the adjacency matrix are meaningless.
    • For undirected graphs, edges in both directions are equivalent, thus the adjacency matrix is symmetric about the main diagonal.
    • By replacing the elements of the adjacency matrix from \\(1\\) and \\(0\\) to weights, it can represent weighted graphs.

    When representing graphs with adjacency matrices, it is possible to directly access matrix elements to obtain edges, thus operations of addition, deletion, lookup, and modification are very efficient, all with a time complexity of \\(O(1)\\). However, the space complexity of the matrix is \\(O(n^2)\\), which consumes more memory.

    "},{"location":"chapter_graph/graph/#2-adjacency-list","title":"2. \u00a0 Adjacency list","text":"

    The \"adjacency list\" uses \\(n\\) linked lists to represent the graph, with each linked list node representing a vertex. The \\(i\\)-th linked list corresponds to vertex \\(i\\) and contains all adjacent vertices (vertices connected to that vertex). The Figure 9-6 shows an example of a graph stored using an adjacency list.

    Figure 9-6 \u00a0 Representation of a graph with an adjacency list

    The adjacency list only stores actual edges, and the total number of edges is often much less than \\(n^2\\), making it more space-efficient. However, finding edges in the adjacency list requires traversing the linked list, so its time efficiency is not as good as that of the adjacency matrix.

    Observing the above figure, the structure of the adjacency list is very similar to the \"chaining\" in hash tables, hence we can use similar methods to optimize efficiency. For example, when the linked list is long, it can be transformed into an AVL tree or red-black tree, thus optimizing the time efficiency from \\(O(n)\\) to \\(O(\\log n)\\); the linked list can also be transformed into a hash table, thus reducing the time complexity to \\(O(1)\\).

    "},{"location":"chapter_graph/graph/#913-common-applications-of-graphs","title":"9.1.3 \u00a0 Common applications of graphs","text":"

    As shown in the Table 9-1 , many real-world systems can be modeled with graphs, and corresponding problems can be reduced to graph computing problems.

    Table 9-1 \u00a0 Common graphs in real life

    Vertices Edges Graph Computing Problem Social Networks Users Friendships Potential Friend Recommendations Subway Lines Stations Connectivity Between Stations Shortest Route Recommendations Solar System Celestial Bodies Gravitational Forces Between Celestial Bodies Planetary Orbit Calculations"},{"location":"chapter_graph/graph_operations/","title":"9.2 \u00a0 Basic operations on graphs","text":"

    The basic operations on graphs can be divided into operations on \"edges\" and operations on \"vertices\". Under the two representation methods of \"adjacency matrix\" and \"adjacency list\", the implementation methods are different.

    "},{"location":"chapter_graph/graph_operations/#921-implementation-based-on-adjacency-matrix","title":"9.2.1 \u00a0 Implementation based on adjacency matrix","text":"

    Given an undirected graph with \\(n\\) vertices, the various operations are implemented as shown in the Figure 9-7 .

    • Adding or removing an edge: Directly modify the specified edge in the adjacency matrix, using \\(O(1)\\) time. Since it is an undirected graph, it is necessary to update the edges in both directions simultaneously.
    • Adding a vertex: Add a row and a column at the end of the adjacency matrix and fill them all with \\(0\\)s, using \\(O(n)\\) time.
    • Removing a vertex: Delete a row and a column in the adjacency matrix. The worst case is when the first row and column are removed, requiring \\((n-1)^2\\) elements to be \"moved up and to the left\", thus using \\(O(n^2)\\) time.
    • Initialization: Pass in \\(n\\) vertices, initialize a vertex list vertices of length \\(n\\), using \\(O(n)\\) time; initialize an \\(n \\times n\\) size adjacency matrix adjMat, using \\(O(n^2)\\) time.
    Initialize adjacency matrixAdd an edgeRemove an edgeAdd a vertexRemove a vertex

    Figure 9-7 \u00a0 Initialization, adding and removing edges, adding and removing vertices in adjacency matrix

    Below is the implementation code for graphs represented using an adjacency matrix:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_adjacency_matrix.py
    class GraphAdjMat:\n    \"\"\"\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\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\n        self.vertices: list[int] = []\n        # \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n        self.adj_mat: list[list[int]] = []\n        # \u6dfb\u52a0\u9876\u70b9\n        for val in vertices:\n            self.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\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\n        n = self.size()\n        # \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        self.vertices.append(val)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"\u5220\u9664\u9876\u70b9\"\"\"\n        if index >= self.size():\n            raise IndexError()\n        # \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        self.vertices.pop(index)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        self.adj_mat.pop(index)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\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\n        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\n            raise IndexError()\n        # \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\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\n        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"\u6253\u5370\u90bb\u63a5\u77e9\u9635\"\"\"\n        print(\"\u9876\u70b9\u5217\u8868 =\", self.vertices)\n        print(\"\u90bb\u63a5\u77e9\u9635 =\")\n        print_matrix(self.adj_mat)\n
    graph_adjacency_matrix.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    vector<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\n    vector<vector<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    GraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {\n        // \u6dfb\u52a0\u9876\u70b9\n        for (int val : vertices) {\n            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\n        for (const vector<int> &edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    void addVertex(int val) {\n        int n = size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.push_back(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        adjMat.emplace_back(vector<int>(n, 0));\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (vector<int> &row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    void removeVertex(int index) {\n        if (index >= size()) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.erase(vertices.begin() + index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.erase(adjMat.begin() + index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (vector<int> &row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    void addEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    void removeEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    void print() {\n        cout << \"\u9876\u70b9\u5217\u8868 = \";\n        printVector(vertices);\n        cout << \"\u90bb\u63a5\u77e9\u9635 =\" << endl;\n        printVectorMatrix(adjMat);\n    }\n};\n
    graph_adjacency_matrix.java
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    List<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\n    List<List<Integer>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList<>();\n        this.adjMat = new ArrayList<>();\n        // \u6dfb\u52a0\u9876\u70b9\n        for (int val : vertices) {\n            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\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void addVertex(int val) {\n        int n = size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.add(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        List<Integer> newRow = new ArrayList<>(n);\n        for (int j = 0; j < n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (List<Integer> row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void removeVertex(int index) {\n        if (index >= size())\n            throw new IndexOutOfBoundsException();\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (List<Integer> row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void addEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void removeEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    public void print() {\n        System.out.print(\"\u9876\u70b9\u5217\u8868 = \");\n        System.out.println(vertices);\n        System.out.println(\"\u90bb\u63a5\u77e9\u9635 =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n
    graph_adjacency_matrix.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    List<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\n    List<List<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        foreach (int val in vertices) {\n            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\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void AddVertex(int val) {\n        int n = Size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.Add(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        List<int> newRow = new(n);\n        for (int j = 0; j < n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        foreach (List<int> row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void RemoveVertex(int index) {\n        if (index >= Size())\n            throw new IndexOutOfRangeException();\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.RemoveAt(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.RemoveAt(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        foreach (List<int> row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void AddEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void RemoveEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    public void Print() {\n        Console.Write(\"\u9876\u70b9\u5217\u8868 = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"\u90bb\u63a5\u77e9\u9635 =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\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\n    vertices []int\n    // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n    adjMat [][]int\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // \u6dfb\u52a0\u9876\u70b9\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // \u521d\u59cb\u5316\u56fe\n    g := &graphAdjMat{\n        vertices: vertices,\n        adjMat:   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\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n    g.vertices = append(g.vertices, val)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index >= g.size() {\n        return\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\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\n    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\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\n    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\t\u9876\u70b9\u5217\u8868 = %v\\n\", g.vertices)\n    fmt.Printf(\"\\t\u90bb\u63a5\u77e9\u9635 = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n
    graph_adjacency_matrix.swift
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    private 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\n    private var adjMat: [[Int]] // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // \u6dfb\u52a0\u9876\u70b9\n        for val in vertices {\n            addVertex(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\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    func size() -> Int {\n        vertices.count\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    func addVertex(val: Int) {\n        let n = size()\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.append(val)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    func removeVertex(index: Int) {\n        if index >= size() {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.remove(at: index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.remove(at: index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    func addEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    func removeEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    func print() {\n        Swift.print(\"\u9876\u70b9\u5217\u8868 = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"\u90bb\u63a5\u77e9\u9635 =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n
    graph_adjacency_matrix.js
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    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\n    adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        for (const val of vertices) {\n            this.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\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(val) {\n        const n = this.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        this.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        const newRow = [];\n        for (let j = 0; j < n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(index) {\n        if (index >= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        this.vertices.splice(index, 1);\n\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        this.adjMat.splice(index, 1);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    addEdge(i, j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    removeEdge(i, j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    print() {\n        console.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\n        console.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 {\n    vertices: 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\n    adjMat: number[][]; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        for (const val of vertices) {\n            this.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\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        this.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        const newRow: number[] = [];\n        for (let j: number = 0; j < n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(index: number): void {\n        if (index >= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        this.vertices.splice(index, 1);\n\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        this.adjMat.splice(index, 1);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    addEdge(i: number, j: number): void {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    removeEdge(i: number, j: number): void {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    print(): void {\n        console.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\n        console.log('\u90bb\u63a5\u77e9\u9635 =', this.adjMat);\n    }\n}\n
    graph_adjacency_matrix.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n  List<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\n  List<List<int>> adjMat = []; //\u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  GraphAdjMat(List<int> vertices, List<List<int>> edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // \u6dfb\u52a0\u9876\u70b9\n    for (int val in vertices) {\n      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\n    for (List<int> e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n  int size() {\n    return vertices.length;\n  }\n\n  /* \u6dfb\u52a0\u9876\u70b9 */\n  void addVertex(int val) {\n    int n = size();\n    // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n    vertices.add(val);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n    List<int> newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n    for (List<int> row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* \u5220\u9664\u9876\u70b9 */\n  void removeVertex(int index) {\n    if (index >= size()) {\n      throw IndexError;\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    vertices.removeAt(index);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    adjMat.removeAt(index);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for (List<int> row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* \u6dfb\u52a0\u8fb9 */\n  // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n  void addEdge(int i, int j) {\n    // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n      throw IndexError;\n    }\n    // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* \u5220\u9664\u8fb9 */\n  // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n  void removeEdge(int i, int j) {\n    // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n  void printAdjMat() {\n    print(\"\u9876\u70b9\u5217\u8868 = $vertices\");\n    print(\"\u90bb\u63a5\u77e9\u9635 = \");\n    printMatrix(adjMat);\n  }\n}\n
    graph_adjacency_matrix.rs
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\u578b */\npub struct GraphAdjMat {\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\n    pub vertices: Vec<i32>,\n    // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n    pub adj_mat: Vec<Vec<i32>>,\n}\n\nimpl GraphAdjMat {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(vertices: Vec<i32>, edges: Vec<[usize; 2]>) -> Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // \u6dfb\u52a0\u9876\u70b9\n        for val in vertices {\n            graph.add_vertex(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\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    pub fn size(&self) -> usize {\n        self.vertices.len()\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    pub fn add_vertex(&mut self, val: i32) {\n        let n = self.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        self.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        self.adj_mat.push(vec![0; n]);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for row in &mut self.adj_mat {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    pub fn remove_vertex(&mut self, index: usize) {\n        if index >= self.size() {\n            panic!(\"index error\")\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        self.vertices.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        self.adj_mat.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for row in &mut self.adj_mat {\n            row.remove(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    pub fn add_edge(&mut self, i: usize, j: usize) {\n        // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i >= self.size() || j >= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    pub fn remove_edge(&mut self, i: usize, j: usize) {\n        // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i >= self.size() || j >= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    pub fn print(&self) {\n        println!(\"\u9876\u70b9\u5217\u8868 = {:?}\", self.vertices);\n        println!(\"\u90bb\u63a5\u77e9\u9635 =\");\n        println!(\"[\");\n        for row in &self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n
    graph_adjacency_matrix.c
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7ed3\u6784\u4f53 */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* \u6784\u9020\u51fd\u6570 */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph->size = 0;\n    for (int i = 0; i < MAX_SIZE; i++) {\n        for (int j = 0; j < MAX_SIZE; j++) {\n            graph->adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph->size == MAX_SIZE) {\n        fprintf(stderr, \"\u56fe\u7684\u9876\u70b9\u6570\u91cf\u5df2\u8fbe\u6700\u5927\u503c\\n\");\n        return;\n    }\n    // \u6dfb\u52a0\u7b2c n \u4e2a\u9876\u70b9\uff0c\u5e76\u5c06\u7b2c n \u884c\u548c\u5217\u7f6e\u96f6\n    int n = graph->size;\n    graph->vertices[n] = val;\n    for (int i = 0; i <= n; i++) {\n        graph->adjMat[n][i] = graph->adjMat[i][n] = 0;\n    }\n    graph->size++;\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index < 0 || index >= graph->size) {\n        fprintf(stderr, \"\u9876\u70b9\u7d22\u5f15\u8d8a\u754c\\n\");\n        return;\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    for (int i = index; i < graph->size - 1; i++) {\n        graph->vertices[i] = graph->vertices[i + 1];\n    }\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    for (int i = index; i < graph->size - 1; i++) {\n        for (int j = 0; j < graph->size; j++) {\n            graph->adjMat[i][j] = graph->adjMat[i + 1][j];\n        }\n    }\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for (int i = 0; i < graph->size; i++) {\n        for (int j = index; j < graph->size - 1; j++) {\n            graph->adjMat[i][j] = graph->adjMat[i][j + 1];\n        }\n    }\n    graph->size--;\n}\n\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {\n        fprintf(stderr, \"\u8fb9\u7d22\u5f15\u8d8a\u754c\u6216\u76f8\u7b49\\n\");\n        return;\n    }\n    graph->adjMat[i][j] = 1;\n    graph->adjMat[j][i] = 1;\n}\n\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {\n        fprintf(stderr, \"\u8fb9\u7d22\u5f15\u8d8a\u754c\u6216\u76f8\u7b49\\n\");\n        return;\n    }\n    graph->adjMat[i][j] = 0;\n    graph->adjMat[j][i] = 0;\n}\n\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"\u9876\u70b9\u5217\u8868 = \");\n    printArray(graph->vertices, graph->size);\n    printf(\"\u90bb\u63a5\u77e9\u9635 =\\n\");\n    for (int i = 0; i < graph->size; i++) {\n        printArray(graph->adjMat[i], graph->size);\n    }\n}\n
    graph_adjacency_matrix.kt
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat(vertices: IntArray, edges: Array<IntArray>) {\n    val vertices: MutableList<Int> = ArrayList() // \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\n    val adjMat: MutableList<MutableList<Int>> = ArrayList() // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        // \u6dfb\u52a0\u9876\u70b9\n        for (vertex in vertices) {\n            addVertex(vertex)\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\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    fun addVertex(value: Int) {\n        val n = size()\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.add(value)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        val newRow: MutableList<Int> = mutableListOf()\n        for (j in 0..<n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    fun removeVertex(index: Int) {\n        if (index >= size()) throw IndexOutOfBoundsException()\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.removeAt(index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.removeAt(index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    fun addEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) throw java.lang.IndexOutOfBoundsException()\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    fun removeEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) throw java.lang.IndexOutOfBoundsException()\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    fun print() {\n        print(\"\u9876\u70b9\u5217\u8868 = \")\n        println(vertices);\n        println(\"\u90bb\u63a5\u77e9\u9635 =\");\n        printMatrix(adjMat)\n    }\n}\n
    graph_adjacency_matrix.rb
    [class]{GraphAdjMat}-[func]{}\n
    graph_adjacency_matrix.zig
    [class]{GraphAdjMat}-[func]{}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_graph/graph_operations/#922-implementation-based-on-adjacency-list","title":"9.2.2 \u00a0 Implementation based on adjacency list","text":"

    Given an undirected graph with a total of \\(n\\) vertices and \\(m\\) edges, the various operations can be implemented as shown in the Figure 9-8 .

    • Adding an edge: Simply add the edge at the end of the corresponding vertex's linked list, using \\(O(1)\\) time. Because it is an undirected graph, it is necessary to add edges in both directions simultaneously.
    • Removing an edge: Find and remove the specified edge in the corresponding vertex's linked list, using \\(O(m)\\) time. In an undirected graph, it is necessary to remove edges in both directions simultaneously.
    • Adding a vertex: Add a linked list in the adjacency list and make the new vertex the head node of the list, using \\(O(1)\\) time.
    • Removing a vertex: It is necessary to traverse the entire adjacency list, removing all edges that include the specified vertex, using \\(O(n + m)\\) time.
    • Initialization: Create \\(n\\) vertices and \\(2m\\) edges in the adjacency list, using \\(O(n + m)\\) time.
    Initialize adjacency listAdd an edgeRemove an edgeAdd a vertexRemove a vertex

    Figure 9-8 \u00a0 Initialization, adding and removing edges, adding and removing vertices in adjacency list

    Below is the adjacency list code implementation. Compared to the above diagram, the actual code has the following differences.

    • For convenience in adding and removing vertices, and to simplify the code, we use lists (dynamic arrays) instead of linked lists.
    • Use a hash table to store the adjacency list, key being the vertex instance, value being the list (linked list) of adjacent vertices of that vertex.

    Additionally, we use the Vertex class to represent vertices in the adjacency list. The reason for this is: if, like with the adjacency matrix, list indexes were used to distinguish different vertices, then suppose you want to delete the vertex at index \\(i\\), you would need to traverse the entire adjacency list and decrement all indexes greater than \\(i\\) by \\(1\\), which is very inefficient. However, if each vertex is a unique Vertex instance, then deleting a vertex does not require any changes to other vertices.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_adjacency_list.py
    class GraphAdjList:\n    \"\"\"\u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        # \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"\u6dfb\u52a0\u8fb9\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # \u6dfb\u52a0\u8fb9 vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"\u5220\u9664\u8fb9\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # \u5220\u9664\u8fb9 vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\n        if vet in self.adj_list:\n            return\n        # \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"\u5220\u9664\u9876\u70b9\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        self.adj_list.pop(vet)\n        # \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u90bb\u63a5\u8868\"\"\"\n        print(\"\u90bb\u63a5\u8868 =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n
    graph_adjacency_list.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n  public:\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    unordered_map<Vertex *, vector<Vertex *>> adjList;\n\n    /* \u5728 vector \u4e2d\u5220\u9664\u6307\u5b9a\u8282\u70b9 */\n    void remove(vector<Vertex *> &vec, Vertex *vet) {\n        for (int i = 0; i < vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    GraphAdjList(const vector<vector<Vertex *>> &edges) {\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const vector<Vertex *> &edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int size() {\n        return adjList.size();\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = vector<Vertex *>();\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.erase(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (auto &adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    void print() {\n        cout << \"\u90bb\u63a5\u8868 =\" << endl;\n        for (auto &adj : adjList) {\n            const auto &key = adj.first;\n            const auto &vec = adj.second;\n            cout << key->val << \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n
    graph_adjacency_list.java
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    Map<Vertex, List<Vertex>> adjList;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap<>();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList.put(vet, new ArrayList<>());\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (List<Vertex> list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public void print() {\n        System.out.println(\"\u90bb\u63a5\u8868 =\");\n        for (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {\n            List<Integer> tmp = new ArrayList<>();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n
    graph_adjacency_list.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    public Dictionary<Vertex, List<Vertex>> adjList;\n\n    /* \u6784\u9020\u51fd\u6570 */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList.Add(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.Remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        foreach (List<Vertex> list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public void Print() {\n        Console.WriteLine(\"\u90bb\u63a5\u8868 =\");\n        foreach (KeyValuePair<Vertex, List<Vertex>> pair in adjList) {\n            List<int> tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList map[Vertex][]Vertex\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* \u6dfb\u52a0\u8fb9 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2, \u6dfb\u52a0\u533f\u540d struct{},\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* \u5220\u9664\u8fb9 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    delete(g.adjList, vet)\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"\u90bb\u63a5\u8868 = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public func size() -> Int {\n        adjList.count\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = []\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.removeValue(forKey: vet)\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public func print() {\n        Swift.print(\"\u90bb\u63a5\u8868 =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(edges) {\n        this.adjList = new Map();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        this.adjList.set(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        this.adjList.delete(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index > -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    print() {\n        console.log('\u90bb\u63a5\u8868 =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList: Map<Vertex, Vertex[]>;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        this.adjList.set(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        this.adjList.delete(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index > -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    print(): void {\n        console.log('\u90bb\u63a5\u8868 =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n
    graph_adjacency_list.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n  // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n  Map<Vertex, List<Vertex>> adjList = {};\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  GraphAdjList(List<List<Vertex>> edges) {\n    for (List<Vertex> edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n  int size() {\n    return adjList.length;\n  }\n\n  /* \u6dfb\u52a0\u8fb9 */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* \u5220\u9664\u8fb9 */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* \u6dfb\u52a0\u9876\u70b9 */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    adjList[vet] = [];\n  }\n\n  /* \u5220\u9664\u9876\u70b9 */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    adjList.remove(vet);\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* \u6253\u5370\u90bb\u63a5\u8868 */\n  void printAdjList() {\n    print(\"\u90bb\u63a5\u8868 =\");\n    adjList.forEach((key, value) {\n      List<int> tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n
    graph_adjacency_list.rs
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\u578b */\npub struct GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    pub adj_list: HashMap<Vertex, Vec<Vertex>>,\n}\n\nimpl GraphAdjList {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(edges: Vec<[Vertex; 2]>) -> Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    #[allow(unused)]\n    pub fn size(&self) -> usize {\n        self.adj_list.len()\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    pub fn add_edge(&mut self, vet1: Vertex, vet2: Vertex) {\n        if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2\n        {\n            panic!(\"value error\");\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        self.adj_list.get_mut(&vet1).unwrap().push(vet2);\n        self.adj_list.get_mut(&vet2).unwrap().push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    #[allow(unused)]\n    pub fn remove_edge(&mut self, vet1: Vertex, vet2: Vertex) {\n        if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2\n        {\n            panic!(\"value error\");\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        self.adj_list\n            .get_mut(&vet1)\n            .unwrap()\n            .retain(|&vet| vet != vet2);\n        self.adj_list\n            .get_mut(&vet2)\n            .unwrap()\n            .retain(|&vet| vet != vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    pub fn add_vertex(&mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&vet) {\n            return;\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    #[allow(unused)]\n    pub fn remove_vertex(&mut self, vet: Vertex) {\n        if !self.adj_list.contains_key(&vet) {\n            panic!(\"value error\");\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        self.adj_list.remove(&vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for list in self.adj_list.values_mut() {\n            list.retain(|&v| v != vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    pub fn print(&self) {\n        println!(\"\u90bb\u63a5\u8868 =\");\n        for (vertex, list) in &self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::<Vec<i32>>();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n
    graph_adjacency_list.c
    /* \u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // \u9876\u70b9\n    struct AdjListNode *next; // \u540e\u7ee7\u8282\u70b9\n} AdjListNode;\n\n/* \u67e5\u627e\u9876\u70b9\u5bf9\u5e94\u7684\u8282\u70b9 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i < graph->size; i++) {\n        if (graph->heads[i]->vertex == vet) {\n            return graph->heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* \u6dfb\u52a0\u8fb9\u8f85\u52a9\u51fd\u6570 */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node->vertex = vet;\n    // \u5934\u63d2\u6cd5\n    node->next = head->next;\n    head->next = node;\n}\n\n/* \u5220\u9664\u8fb9\u8f85\u52a9\u51fd\u6570 */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head->next;\n    // \u5728\u94fe\u8868\u4e2d\u641c\u7d22 vet \u5bf9\u5e94\u8282\u70b9\n    while (cur != NULL && cur->vertex != vet) {\n        pre = cur;\n        cur = cur->next;\n    }\n    if (cur == NULL)\n        return;\n    // \u5c06 vet \u5bf9\u5e94\u8282\u70b9\u4ece\u94fe\u8868\u4e2d\u5220\u9664\n    pre->next = cur->next;\n    // \u91ca\u653e\u5185\u5b58\n    free(cur);\n}\n\n/* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // \u8282\u70b9\u6570\u7ec4\n    int size;                     // \u8282\u70b9\u6570\u91cf\n} GraphAdjList;\n\n/* \u6784\u9020\u51fd\u6570 */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph->size = 0;\n    for (int i = 0; i < MAX_SIZE; i++) {\n        graph->heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i < graph->size; i++) {\n        AdjListNode *cur = graph->heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur->next;\n            if (cur != graph->heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph->heads[i]->vertex);\n        free(graph->heads[i]);\n    }\n    free(graph);\n}\n\n/* \u67e5\u627e\u9876\u70b9\u5bf9\u5e94\u7684\u8282\u70b9 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i < graph->size; i++) {\n        if (graph->heads[i]->vertex == vet) {\n            return graph->heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* \u6dfb\u52a0\u8fb9 */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL && head2 != NULL && head1 != head2);\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* \u5220\u9664\u8fb9 */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL && head2 != NULL);\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    removeEdgeHelper(head1, head2->vertex);\n    removeEdgeHelper(head2, head1->vertex);\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL && graph->size < MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head->vertex = vet;\n    head->next = NULL;\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    graph->heads[graph->size++] = head;\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur->next;\n        free(pre);\n    }\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    for (int i = 0; i < graph->size; i++) {\n        cur = graph->heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur->next;\n            if (cur && cur->vertex == vet) {\n                pre->next = cur->next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // \u5c06\u8be5\u9876\u70b9\u4e4b\u540e\u7684\u9876\u70b9\u5411\u524d\u79fb\u52a8\uff0c\u4ee5\u586b\u8865\u7a7a\u7f3a\n    int i;\n    for (i = 0; i < graph->size; i++) {\n        if (graph->heads[i] == node)\n            break;\n    }\n    for (int j = i; j < graph->size - 1; j++) {\n        graph->heads[j] = graph->heads[j + 1];\n    }\n    graph->size--;\n    free(vet);\n}\n
    graph_adjacency_list.kt
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList(edges: Array<Array<Vertex?>>) {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    val adjList: MutableMap<Vertex, MutableList<Vertex>> = HashMap()\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (edge in edges) {\n            addVertex(edge[0]!!);\n            addVertex(edge[1]!!);\n            addEdge(edge[0]!!, edge[1]!!);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1]?.remove(vet2);\n        adjList[vet2]?.remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = mutableListOf()\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    fun print() {\n        println(\"\u90bb\u63a5\u8868 =\")\n        for (pair in adjList.entries) {\n            val tmp = ArrayList<Int>()\n            for (vertex in pair.value) {\n                tmp.add(vertex.value)\n            }\n            println(\"${pair.key.value}: $tmp,\")\n        }\n    }\n}\n
    graph_adjacency_list.rb
    [class]{GraphAdjList}-[func]{}\n
    graph_adjacency_list.zig
    [class]{GraphAdjList}-[func]{}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_graph/graph_operations/#923-efficiency-comparison","title":"9.2.3 \u00a0 Efficiency comparison","text":"

    Assuming there are \\(n\\) vertices and \\(m\\) edges in the graph, the Table 9-2 compares the time efficiency and space efficiency of the adjacency matrix and adjacency list.

    Table 9-2 \u00a0 Comparison of adjacency matrix and adjacency list

    Adjacency matrix Adjacency list (Linked list) Adjacency list (Hash table) Determine adjacency \\(O(1)\\) \\(O(m)\\) \\(O(1)\\) Add an edge \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Remove an edge \\(O(1)\\) \\(O(m)\\) \\(O(1)\\) Add a vertex \\(O(n)\\) \\(O(1)\\) \\(O(1)\\) Remove a vertex \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n)\\) Memory space usage \\(O(n^2)\\) \\(O(n + m)\\) \\(O(n + m)\\)

    Observing the Table 9-2 , it seems that the adjacency list (hash table) has the best time efficiency and space efficiency. However, in practice, operating on edges in the adjacency matrix is more efficient, requiring only a single array access or assignment operation. Overall, the adjacency matrix exemplifies the principle of \"space for time\", while the adjacency list exemplifies \"time for space\".

    "},{"location":"chapter_graph/graph_traversal/","title":"9.3 \u00a0 Graph traversal","text":"

    Trees represent a \"one-to-many\" relationship, while graphs have a higher degree of freedom and can represent any \"many-to-many\" relationship. Therefore, we can consider trees as a special case of graphs. Clearly, tree traversal operations are also a special case of graph traversal operations.

    Both graphs and trees require the application of search algorithms to implement traversal operations. Graph traversal can be divided into two types: \"Breadth-First Search (BFS)\" and \"Depth-First Search (DFS)\".

    "},{"location":"chapter_graph/graph_traversal/#931-breadth-first-search","title":"9.3.1 \u00a0 Breadth-first search","text":"

    Breadth-first search is a near-to-far traversal method, starting from a certain node, always prioritizing the visit to the nearest vertices and expanding outwards layer by layer. As shown in the Figure 9-9 , starting from the top left vertex, first traverse all adjacent vertices of that vertex, then traverse all adjacent vertices of the next vertex, and so on, until all vertices have been visited.

    Figure 9-9 \u00a0 Breadth-first traversal of a graph

    "},{"location":"chapter_graph/graph_traversal/#1-algorithm-implementation","title":"1. \u00a0 Algorithm implementation","text":"

    BFS is usually implemented with the help of a queue, as shown in the code below. The queue has a \"first in, first out\" property, which aligns with the BFS idea of traversing \"from near to far\".

    1. Add the starting vertex startVet to the queue and start the loop.
    2. In each iteration of the loop, pop the vertex at the front of the queue and record it as visited, then add all adjacent vertices of that vertex to the back of the queue.
    3. Repeat step 2. until all vertices have been visited.

    To prevent revisiting vertices, we use a hash table visited to record which nodes have been visited.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_bfs.py
    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n    \"\"\"\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\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\n    res = []\n    # \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited = set[Vertex]([start_vet])\n    # \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    que = deque[Vertex]([start_vet])\n    # \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while len(que) > 0:\n        vet = que.popleft()  # \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        # \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.append(adj_vet)  # \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adj_vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    # \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n
    graph_bfs.cpp
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    vector<Vertex *> res;\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    unordered_set<Vertex *> visited = {startVet};\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    queue<Vertex *> que;\n    que.push(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push_back(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.push(adjVet);        // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.emplace(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.java
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = new ArrayList<>();\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    Set<Vertex> visited = new HashSet<>();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue<Vertex> que = new LinkedList<>();\n    que.offer(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.add(vet);            // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.offer(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.cs
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    HashSet<Vertex> visited = [startVet];\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue<Vertex> que = new();\n    que.Enqueue(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.Count > 0) {\n        Vertex vet = que.Dequeue(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.Add(vet);               // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.Enqueue(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.Add(adjVet);   // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.go
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    res := make([]Vertex, 0)\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS, \u4f7f\u7528\u5207\u7247\u6a21\u62df\u961f\u5217\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    for len(queue) > 0 {\n        // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        vet := queue[0]\n        queue = queue[1:]\n        // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        res = append(res, vet)\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.swift
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    var res: [Vertex] = []\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    var visited: Set<Vertex> = [startVet]\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    var que: [Vertex] = [startVet]\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while !que.isEmpty {\n        let vet = que.removeFirst() // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.append(adjVet) // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.insert(adjVet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.js
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited = new Set();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    const que = [startVet];\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.length) {\n        const vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.ts
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res: Vertex[] = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited: Set<Vertex> = new Set();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    const que = [startVet];\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.length) {\n        const vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.dart
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n  List<Vertex> res = [];\n  // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n  Set<Vertex> visited = {};\n  visited.add(startVet);\n  // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n  Queue<Vertex> que = Queue();\n  que.add(startVet);\n  // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n    res.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n      }\n      que.add(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n      visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    }\n  }\n  // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n  return res;\n}\n
    graph_bfs.rs
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    let mut res = vec![];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while !que.is_empty() {\n        let vet = que.pop_front().unwrap(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        if let Some(adj_vets) = graph.adj_list.get(&vet) {\n            for &adj_vet in adj_vets {\n                if visited.contains(&adj_vet) {\n                    continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n                }\n                que.push_back(adj_vet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n                visited.insert(adj_vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n            }\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    res\n}\n
    graph_bfs.c
    /* \u8282\u70b9\u961f\u5217\u7ed3\u6784\u4f53 */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* \u6784\u9020\u51fd\u6570 */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q->front = q->rear = q->size = 0;\n    return q;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nint isEmpty(Queue *q) {\n    return q->size == 0;\n}\n\n/* \u5165\u961f\u64cd\u4f5c */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q->vertices[q->rear] = vet;\n    q->rear = (q->rear + 1) % MAX_SIZE;\n    q->size++;\n}\n\n/* \u51fa\u961f\u64cd\u4f5c */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q->vertices[q->front];\n    q->front = (q->front + 1) % MAX_SIZE;\n    q->size--;\n    return vet;\n}\n\n/* \u68c0\u67e5\u9876\u70b9\u662f\u5426\u5df2\u88ab\u8bbf\u95ee */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // \u904d\u5386\u67e5\u627e\u8282\u70b9\uff0c\u4f7f\u7528 O(n) \u65f6\u95f4\n    for (int i = 0; i < size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res[(*resSize)++] = vet;      // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            if (!isVisited(visited, *visitedSize, node->vertex)) {\n                enqueue(queue, node->vertex);             // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n                visited[(*visitedSize)++] = node->vertex; // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n            }\n            node = node->next;\n        }\n    }\n    // \u91ca\u653e\u5185\u5b58\n    free(queue);\n}\n
    graph_bfs.kt
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): List<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    val res: MutableList<Vertex> = ArrayList()\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    val visited: MutableSet<Vertex> = HashSet()\n    visited.add(startVet)\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    val que: Queue<Vertex> = LinkedList()\n    que.offer(startVet)\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.isEmpty()) {\n        val vet = que.poll() // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.add(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet)) continue  // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n\n            que.offer(adjVet) // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.rb
    [class]{}-[func]{graph_bfs}\n
    graph_bfs.zig
    [class]{}-[func]{graphBFS}\n
    Code Visualization

    Full Screen >

    The code is relatively abstract, it is suggested to compare with the following figure to deepen the understanding.

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

    Figure 9-10 \u00a0 Steps of breadth-first search of a graph

    Is the sequence of breadth-first traversal unique?

    Not unique. Breadth-first traversal only requires traversing in a \"from near to far\" order, and the traversal order of multiple vertices at the same distance can be arbitrarily shuffled. For example, in the above figure, the visitation order of vertices \\(1\\) and \\(3\\) can be switched, as can the order of vertices \\(2\\), \\(4\\), and \\(6\\).

    "},{"location":"chapter_graph/graph_traversal/#2-complexity-analysis","title":"2. \u00a0 Complexity analysis","text":"

    Time complexity: All vertices will be enqueued and dequeued once, using \\(O(|V|)\\) time; in the process of traversing adjacent vertices, since it is an undirected graph, all edges will be visited \\(2\\) times, using \\(O(2|E|)\\) time; overall using \\(O(|V| + |E|)\\) time.

    Space complexity: The maximum number of vertices in list res, hash table visited, and queue que is \\(|V|\\), using \\(O(|V|)\\) space.

    "},{"location":"chapter_graph/graph_traversal/#932-depth-first-search","title":"9.3.2 \u00a0 Depth-first search","text":"

    Depth-first search is a traversal method that prioritizes going as far as possible and then backtracks when no further paths are available. As shown in the Figure 9-11 , starting from the top left vertex, visit some adjacent vertex of the current vertex until no further path is available, then return and continue until all vertices are traversed.

    Figure 9-11 \u00a0 Depth-first traversal of a graph

    "},{"location":"chapter_graph/graph_traversal/#1-algorithm-implementation_1","title":"1. \u00a0 Algorithm implementation","text":"

    This \"go as far as possible and then return\" algorithm paradigm is usually implemented based on recursion. Similar to breadth-first search, in depth-first search, we also need the help of a hash table visited to record the visited vertices to avoid revisiting.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_dfs.py
    def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570\"\"\"\n    res.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    # \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        # \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n    \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\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\n    res = []\n    # \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n
    graph_dfs.cpp
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {\n    res.push_back(vet);   // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.emplace(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    vector<Vertex *> res;\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    unordered_set<Vertex *> visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.java
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {\n    res.add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = new ArrayList<>();\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    Set<Vertex> visited = new HashSet<>();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.cs
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid DFS(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {\n    res.Add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.Add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9                             \n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    HashSet<Vertex> visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.go
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\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)\n    visited[vet] = struct{}{}\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    res := make([]Vertex, 0)\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &res, startVet)\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_dfs.swift
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfunc dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.insert(vet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph: graph, visited: &visited, res: &res, vet: adjVet)\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    var res: [Vertex] = []\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    var visited: Set<Vertex> = []\n    dfs(graph: graph, visited: &visited, res: &res, vet: startVet)\n    return res\n}\n
    graph_dfs.js
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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) {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.ts
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set<Vertex>,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res: Vertex[] = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited: Set<Vertex> = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.dart
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(\n  GraphAdjList graph,\n  Set<Vertex> visited,\n  List<Vertex> res,\n  Vertex vet,\n) {\n  res.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n  visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n  // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n    }\n    // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n  // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n  List<Vertex> res = [];\n  // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n  Set<Vertex> visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n
    graph_dfs.rs
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfn dfs(graph: &GraphAdjList, visited: &mut HashSet<Vertex>, res: &mut Vec<Vertex>, vet: Vertex) {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.insert(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n                         // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    if let Some(adj_vets) = graph.adj_list.get(&vet) {\n        for &adj_vet in adj_vets {\n            if visited.contains(&adj_vet) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    let mut res = vec![];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    let mut visited = HashSet::new();\n    dfs(&graph, &mut visited, &mut res, start_vet);\n\n    res\n}\n
    graph_dfs.c
    /* \u68c0\u67e5\u9876\u70b9\u662f\u5426\u5df2\u88ab\u8bbf\u95ee */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // \u904d\u5386\u67e5\u627e\u8282\u70b9\uff0c\u4f7f\u7528 O(n) \u65f6\u95f4\n    for (int i = 0; i < size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    res[(*resSize)++] = vet;\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        if (!isVisited(res, *resSize, node->vertex)) {\n            // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n            dfs(graph, res, resSize, node->vertex);\n        }\n        node = node->next;\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n
    graph_dfs.kt
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet<Vertex?>,\n    res: MutableList<Vertex?>,\n    vet: Vertex?\n) {\n    res.add(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet)) continue  // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfun graphDFS(\n    graph: GraphAdjList,\n    startVet: Vertex?\n): List<Vertex?> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    val res: MutableList<Vertex?> = ArrayList()\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    val visited: MutableSet<Vertex?> = HashSet()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n
    graph_dfs.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{graph_dfs}\n
    graph_dfs.zig
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{graphDFS}\n
    Code Visualization

    Full Screen >

    The algorithm process of depth-first search is shown in the following figure.

    • Dashed lines represent downward recursion, indicating that a new recursive method has been initiated to visit a new vertex.
    • Curved dashed lines represent upward backtracking, indicating that this recursive method has returned to the position where this method was initiated.

    To deepen the understanding, it is suggested to combine the following figure with the code to simulate (or draw) the entire DFS process in your mind, including when each recursive method is initiated and when it returns.

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

    Figure 9-12 \u00a0 Steps of depth-first search of a graph

    Is the sequence of depth-first traversal unique?

    Similar to breadth-first traversal, the order of the depth-first traversal sequence is also not unique. Given a certain vertex, exploring in any direction first is possible, that is, the order of adjacent vertices can be arbitrarily shuffled, all being part of depth-first traversal.

    Taking tree traversal as an example, \"root \\(\\rightarrow\\) left \\(\\rightarrow\\) right\", \"left \\(\\rightarrow\\) root \\(\\rightarrow\\) right\", \"left \\(\\rightarrow\\) right \\(\\rightarrow\\) root\" correspond to preorder, inorder, and postorder traversals, respectively. They showcase three types of traversal priorities, yet all three are considered depth-first traversal.

    "},{"location":"chapter_graph/graph_traversal/#2-complexity-analysis_1","title":"2. \u00a0 Complexity analysis","text":"

    Time complexity: All vertices will be visited once, using \\(O(|V|)\\) time; all edges will be visited twice, using \\(O(2|E|)\\) time; overall using \\(O(|V| + |E|)\\) time.

    Space complexity: The maximum number of vertices in list res, hash table visited is \\(|V|\\), and the maximum recursion depth is \\(|V|\\), therefore using \\(O(|V|)\\) space.

    "},{"location":"chapter_graph/summary/","title":"9.4 \u00a0 Summary","text":""},{"location":"chapter_graph/summary/#1-key-review","title":"1. \u00a0 Key review","text":"
    • A graph consists of vertices and edges and can be represented as a set comprising a group of vertices and a group of edges.
    • Compared to linear relationships (linked lists) and divide-and-conquer relationships (trees), network relationships (graphs) have a higher degree of freedom and are therefore more complex.
    • The edges of a directed graph have directionality, any vertex in a connected graph is reachable, and each edge in a weighted graph contains a weight variable.
    • Adjacency matrices use matrices to represent graphs, with each row (column) representing a vertex and matrix elements representing edges, using \\(1\\) or \\(0\\) to indicate the presence or absence of an edge between two vertices. Adjacency matrices are highly efficient for add, delete, find, and modify operations, but they consume more space.
    • Adjacency lists use multiple linked lists to represent graphs, with the \\(i^{th}\\) list corresponding to vertex \\(i\\), containing all its adjacent vertices. Adjacency lists save more space compared to adjacency matrices, but since it is necessary to traverse the list to find edges, their time efficiency is lower.
    • When the linked lists in the adjacency list are too long, they can be converted into red-black trees or hash tables to improve query efficiency.
    • From the perspective of algorithmic thinking, adjacency matrices embody the principle of \"space for time,\" while adjacency lists embody \"time for space.\"
    • Graphs can be used to model various real systems, such as social networks, subway routes, etc.
    • A tree is a special case of a graph, and tree traversal is also a special case of graph traversal.
    • Breadth-first traversal of a graph is a search method that expands layer by layer from near to far, usually implemented with a queue.
    • Depth-first traversal of a graph is a search method that prefers to go as deep as possible and backtracks when no further paths are available, often based on recursion.
    "},{"location":"chapter_graph/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Is a path defined as a sequence of vertices or a sequence of edges?

    Definitions vary between different language versions on Wikipedia: the English version defines a path as \"a sequence of edges,\" while the Chinese version defines it as \"a sequence of vertices.\" Here is the original text from the English version: In graph theory, a path in a graph is a finite or infinite sequence of edges which joins a sequence of vertices.

    In this document, a path is considered a sequence of edges, rather than a sequence of vertices. This is because there might be multiple edges connecting two vertices, in which case each edge corresponds to a path.

    Q: In a disconnected graph, are there points that cannot be traversed to?

    In a disconnected graph, starting from a certain vertex, there is at least one vertex that cannot be reached. Traversing a disconnected graph requires setting multiple starting points to traverse all connected components of the graph.

    Q: In an adjacency list, does the order of \"all vertices connected to that vertex\" matter?

    It can be in any order. However, in practical applications, it might be necessary to sort according to certain rules, such as the order in which vertices are added, or the order of vertex values, etc., to facilitate the quick search for vertices with certain extremal values.

    "},{"location":"chapter_hashing/","title":"Chapter 6. \u00a0 Hash Table","text":"

    Abstract

    In the world of computing, a hash table is akin to an intelligent librarian.

    It understands how to compute index numbers, enabling swift retrieval of the desired book.

    "},{"location":"chapter_hashing/#chapter-contents","title":"Chapter Contents","text":"
    • 6.1 \u00a0 Hash Table
    • 6.2 \u00a0 Hash Collision
    • 6.3 \u00a0 Hash Algorithm
    • 6.4 \u00a0 Summary
    "},{"location":"chapter_hashing/hash_algorithm/","title":"6.3 \u00a0 Hash Algorithms","text":"

    The previous two sections introduced the working principle of hash tables and the methods to handle hash collisions. However, both open addressing and chaining can only ensure that the hash table functions normally when collisions occur, but cannot reduce the frequency of hash collisions.

    If hash collisions occur too frequently, the performance of the hash table will deteriorate drastically. As shown in the Figure 6-8 , for a chaining hash table, in the ideal case, the key-value pairs are evenly distributed across the buckets, achieving optimal query efficiency; in the worst case, all key-value pairs are stored in the same bucket, degrading the time complexity to \\(O(n)\\).

    Figure 6-8 \u00a0 Ideal and Worst Cases of Hash Collisions

    The distribution of key-value pairs is determined by the hash function. Recalling the steps of calculating a hash function, first compute the hash value, then modulo it by the array length:

    index = hash(key) % capacity\n

    Observing the above formula, when the hash table capacity capacity is fixed, the hash algorithm hash() determines the output value, thereby determining the distribution of key-value pairs in the hash table.

    This means that, to reduce the probability of hash collisions, we should focus on the design of the hash algorithm hash().

    "},{"location":"chapter_hashing/hash_algorithm/#631-goals-of-hash-algorithms","title":"6.3.1 \u00a0 Goals of Hash Algorithms","text":"

    To achieve a \"fast and stable\" hash table data structure, hash algorithms should have the following characteristics:

    • Determinism: For the same input, the hash algorithm should always produce the same output. Only then can the hash table be reliable.
    • High Efficiency: The process of computing the hash value should be fast enough. The smaller the computational overhead, the more practical the hash table.
    • Uniform Distribution: The hash algorithm should ensure that key-value pairs are evenly distributed in the hash table. The more uniform the distribution, the lower the probability of hash collisions.

    In fact, hash algorithms are not only used to implement hash tables but are also widely applied in other fields.

    • Password Storage: To protect the security of user passwords, systems usually do not store the plaintext passwords but rather the hash values of the passwords. When a user enters a password, the system calculates the hash value of the input and compares it with the stored hash value. If they match, the password is considered correct.
    • Data Integrity Check: The data sender can calculate the hash value of the data and send it along; the receiver can recalculate the hash value of the received data and compare it with the received hash value. If they match, the data is considered intact.

    For cryptographic applications, to prevent reverse engineering such as deducing the original password from the hash value, hash algorithms need higher-level security features.

    • Unidirectionality: It should be impossible to deduce any information about the input data from the hash value.
    • Collision Resistance: It should be extremely difficult to find two different inputs that produce the same hash value.
    • Avalanche Effect: Minor changes in the input should lead to significant and unpredictable changes in the output.

    Note that \"Uniform Distribution\" and \"Collision Resistance\" are two separate concepts. Satisfying uniform distribution does not necessarily mean collision resistance. For example, under random input key, the hash function key % 100 can produce a uniformly distributed output. However, this hash algorithm is too simple, and all key with the same last two digits will have the same output, making it easy to deduce a usable key from the hash value, thereby cracking the password.

    "},{"location":"chapter_hashing/hash_algorithm/#632-design-of-hash-algorithms","title":"6.3.2 \u00a0 Design of Hash Algorithms","text":"

    The design of hash algorithms is a complex issue that requires consideration of many factors. However, for some less demanding scenarios, we can also design some simple hash algorithms.

    • Additive Hash: Add up the ASCII codes of each character in the input and use the total sum as the hash value.
    • Multiplicative Hash: Utilize the non-correlation of multiplication, multiplying each round by a constant, accumulating the ASCII codes of each character into the hash value.
    • XOR Hash: Accumulate the hash value by XORing each element of the input data.
    • Rotating Hash: Accumulate the ASCII code of each character into a hash value, performing a rotation operation on the hash value before each accumulation.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig simple_hash.py
    def add_hash(key: str) -> int:\n    \"\"\"\u52a0\u6cd5\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -> int:\n    \"\"\"\u4e58\u6cd5\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -> int:\n    \"\"\"\u5f02\u6216\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -> int:\n    \"\"\"\u65cb\u8f6c\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash << 4) ^ (hash >> 28) ^ ord(c)\n    return hash % modulus\n
    simple_hash.cpp
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n
    simple_hash.java
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n
    simple_hash.cs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n
    simple_hash.go
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash & modulus\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n
    simple_hash.swift
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash & MODULUS\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash << 4) ^ (hash >> 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n
    simple_hash.js
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n
    simple_hash.ts
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n
    simple_hash.dart
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n
    simple_hash.rs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfn add_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfn mul_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfn xor_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash & MODULUS) as i32\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfn rot_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n
    simple_hash.c
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i < strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n
    simple_hash.kt
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfun addHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfun xorHash(key: String): Int {\n    var hash = 0\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n
    simple_hash.rb
    [class]{}-[func]{add_hash}\n\n[class]{}-[func]{mul_hash}\n\n[class]{}-[func]{xor_hash}\n\n[class]{}-[func]{rot_hash}\n
    simple_hash.zig
    [class]{}-[func]{addHash}\n\n[class]{}-[func]{mulHash}\n\n[class]{}-[func]{xorHash}\n\n[class]{}-[func]{rotHash}\n
    Code Visualization

    Full Screen >

    It is observed that the last step of each hash algorithm is to take the modulus of the large prime number \\(1000000007\\) to ensure that the hash value is within an appropriate range. It is worth pondering why emphasis is placed on modulo a prime number, or what are the disadvantages of modulo a composite number? This is an interesting question.

    To conclude: Using a large prime number as the modulus can maximize the uniform distribution of hash values. Since a prime number does not share common factors with other numbers, it can reduce the periodic patterns caused by the modulo operation, thus avoiding hash collisions.

    For example, suppose we choose the composite number \\(9\\) as the modulus, which can be divided by \\(3\\), then all key divisible by \\(3\\) will be mapped to hash values \\(0\\), \\(3\\), \\(6\\).

    \\[ \\begin{aligned} \\text{modulus} & = 9 \\newline \\text{key} & = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\end{aligned} \\]

    If the input key happens to have this kind of arithmetic sequence distribution, then the hash values will cluster, thereby exacerbating hash collisions. Now, suppose we replace modulus with the prime number \\(13\\), since there are no common factors between key and modulus, the uniformity of the output hash values will be significantly improved.

    \\[ \\begin{aligned} \\text{modulus} & = 13 \\newline \\text{key} & = \\{ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, \\dots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\]

    It is worth noting that if the key is guaranteed to be randomly and uniformly distributed, then choosing a prime number or a composite number as the modulus can both produce uniformly distributed hash values. However, when the distribution of key has some periodicity, modulo a composite number is more likely to result in clustering.

    In summary, we usually choose a prime number as the modulus, and this prime number should be large enough to eliminate periodic patterns as much as possible, enhancing the robustness of the hash algorithm.

    "},{"location":"chapter_hashing/hash_algorithm/#633-common-hash-algorithms","title":"6.3.3 \u00a0 Common Hash Algorithms","text":"

    It is not hard to see that the simple hash algorithms mentioned above are quite \"fragile\" and far from reaching the design goals of hash algorithms. For example, since addition and XOR obey the commutative law, additive hash and XOR hash cannot distinguish strings with the same content but in different order, which may exacerbate hash collisions and cause security issues.

    In practice, we usually use some standard hash algorithms, such as MD5, SHA-1, SHA-2, and SHA-3. They can map input data of any length to a fixed-length hash value.

    Over the past century, hash algorithms have been in a continuous process of upgrading and optimization. Some researchers strive to improve the performance of hash algorithms, while others, including hackers, are dedicated to finding security issues in hash algorithms. The Table 6-2 shows hash algorithms commonly used in practical applications.

    • MD5 and SHA-1 have been successfully attacked multiple times and are thus abandoned in various security applications.
    • SHA-2 series, especially SHA-256, is one of the most secure hash algorithms to date, with no successful attacks reported, hence commonly used in various security applications and protocols.
    • SHA-3 has lower implementation costs and higher computational efficiency compared to SHA-2, but its current usage coverage is not as extensive as the SHA-2 series.

    Table 6-2 \u00a0 Common Hash Algorithms

    MD5 SHA-1 SHA-2 SHA-3 Release Year 1992 1995 2002 2008 Output Length 128 bit 160 bit 256/512 bit 224/256/384/512 bit Hash Collisions Frequent Frequent Rare Rare Security Level Low, has been successfully attacked Low, has been successfully attacked High High Applications Abandoned, still used for data integrity checks Abandoned Cryptocurrency transaction verification, digital signatures, etc. Can be used to replace SHA-2"},{"location":"chapter_hashing/hash_algorithm/#hash-values-in-data-structures","title":"Hash Values in Data Structures","text":"

    We know that the keys in a hash table can be of various data types such as integers, decimals, or strings. Programming languages usually provide built-in hash algorithms for these data types to calculate the bucket indices in the hash table. Taking Python as an example, we can use the hash() function to compute the hash values for various data types.

    • The hash values of integers and booleans are their own values.
    • The calculation of hash values for floating-point numbers and strings is more complex, and interested readers are encouraged to study this on their own.
    • The hash value of a tuple is a combination of the hash values of each of its elements, resulting in a single hash value.
    • The hash value of an object is generated based on its memory address. By overriding the hash method of an object, hash values can be generated based on content.

    Tip

    Be aware that the definition and methods of the built-in hash value calculation functions in different programming languages vary.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig built_in_hash.py
    num = 3\nhash_num = hash(num)\n# Hash value of integer 3 is 3\n\nbol = True\nhash_bol = hash(bol)\n# Hash value of boolean True is 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# Hash value of decimal 3.14159 is 326484311674566659\n\nstr = \"Hello \u7b97\u6cd5\"\nhash_str = hash(str)\n# Hash value of string \"Hello \u7b97\u6cd5\" is 4617003410720528961\n\ntup = (12836, \"\u5c0f\u54c8\")\nhash_tup = hash(tup)\n# Hash value of tuple (12836, '\u5c0f\u54c8') is 1029005403108185979\n\nobj = ListNode(0)\nhash_obj = hash(obj)\n# Hash value of ListNode object at 0x1058fd810 is 274267521\n
    built_in_hash.cpp
    int num = 3;\nsize_t hashNum = hash<int>()(num);\n// Hash value of integer 3 is 3\n\nbool bol = true;\nsize_t hashBol = hash<bool>()(bol);\n// Hash value of boolean 1 is 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash<double>()(dec);\n// Hash value of decimal 3.14159 is 4614256650576692846\n\nstring str = \"Hello \u7b97\u6cd5\";\nsize_t hashStr = hash<string>()(str);\n// Hash value of string \"Hello \u7b97\u6cd5\" is 15466937326284535026\n\n// In C++, built-in std::hash() only provides hash values for basic data types\n// Hash values for arrays and objects need to be implemented separately\n
    built_in_hash.java
    int num = 3;\nint hashNum = Integer.hashCode(num);\n// Hash value of integer 3 is 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// Hash value of boolean true is 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// Hash value of decimal 3.14159 is -1340954729\n\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode();\n// Hash value of string \"Hello \u7b97\u6cd5\" is -727081396\n\nObject[] arr = { 12836, \"\u5c0f\u54c8\" };\nint hashTup = Arrays.hashCode(arr);\n// Hash value of array [12836, \u5c0f\u54c8] is 1151158\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode();\n// Hash value of ListNode object utils.ListNode@7dc5e7b4 is 2110121908\n
    built_in_hash.cs
    int num = 3;\nint hashNum = num.GetHashCode();\n// Hash value of integer 3 is 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// Hash value of boolean true is 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// Hash value of decimal 3.14159 is -1340954729;\n\nstring str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.GetHashCode();\n// Hash value of string \"Hello \u7b97\u6cd5\" is -586107568;\n\nobject[] arr = [12836, \"\u5c0f\u54c8\"];\nint hashTup = arr.GetHashCode();\n// Hash value of array [12836, \u5c0f\u54c8] is 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// Hash value of ListNode object 0 is 39053774;\n
    built_in_hash.go
    // Go does not provide built-in hash code functions\n
    built_in_hash.swift
    let num = 3\nlet hashNum = num.hashValue\n// Hash value of integer 3 is 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// Hash value of boolean true is -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// Hash value of decimal 3.14159 is -2465384235396674631\n\nlet str = \"Hello \u7b97\u6cd5\"\nlet hashStr = str.hashValue\n// Hash value of string \"Hello \u7b97\u6cd5\" is -7850626797806988787\n\nlet arr = [AnyHashable(12836), AnyHashable(\"\u5c0f\u54c8\")]\nlet hashTup = arr.hashValue\n// Hash value of array [AnyHashable(12836), AnyHashable(\"\u5c0f\u54c8\")] is -2308633508154532996\n\nlet obj = ListNode(x: 0)\nlet hashObj = obj.hashValue\n// Hash value of ListNode object utils.ListNode is -2434780518035996159\n
    built_in_hash.js
    // JavaScript does not provide built-in hash code functions\n
    built_in_hash.ts
    // TypeScript does not provide built-in hash code functions\n
    built_in_hash.dart
    int num = 3;\nint hashNum = num.hashCode;\n// Hash value of integer 3 is 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// Hash value of boolean true is 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// Hash value of decimal 3.14159 is 2570631074981783\n\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode;\n// Hash value of string \"Hello \u7b97\u6cd5\" is 468167534\n\nList arr = [12836, \"\u5c0f\u54c8\"];\nint hashArr = arr.hashCode;\n// Hash value of array [12836, \u5c0f\u54c8] is 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// Hash value of ListNode object Instance of 'ListNode' is 1033450432\n
    built_in_hash.rs
    use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&mut num_hasher);\nlet hash_num = num_hasher.finish();\n// Hash value of integer 3 is 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// Hash value of boolean true is 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// Hash value of decimal 3.14159 is 2566941990314602357\n\nlet str = \"Hello \u7b97\u6cd5\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&mut str_hasher);\nlet hash_str = str_hasher.finish();\n// Hash value of string \"Hello \u7b97\u6cd5\" is 16092673739211250988\n\nlet arr = (&12836, &\"\u5c0f\u54c8\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// Hash value of tuple (12836, \"\u5c0f\u54c8\") is 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&mut hasher);\nlet hash = hasher.finish();\n// Hash value of ListNode object RefCell { value: ListNode { val: 42, next: None } } is 15387811073369036852\n
    built_in_hash.c
    // C does not provide built-in hash code functions\n
    built_in_hash.kt
    \n
    built_in_hash.zig
    \n
    Code Visualization

    Full Screen >

    In many programming languages, only immutable objects can serve as the key in a hash table. If we use a list (dynamic array) as a key, when the contents of the list change, its hash value also changes, and we would no longer be able to find the original value in the hash table.

    Although the member variables of a custom object (such as a linked list node) are mutable, it is hashable. This is because the hash value of an object is usually generated based on its memory address, and even if the contents of the object change, the memory address remains the same, so the hash value remains unchanged.

    You might have noticed that the hash values output in different consoles are different. This is because the Python interpreter adds a random salt to the string hash function each time it starts up. This approach effectively prevents HashDoS attacks and enhances the security of the hash algorithm.

    "},{"location":"chapter_hashing/hash_collision/","title":"6.2 \u00a0 Hash Collision","text":"

    As mentioned in the previous section, usually the input space of a hash function is much larger than its output space, making hash collisions theoretically inevitable. For example, if the input space consists of all integers and the output space is the size of the array capacity, multiple integers will inevitably map to the same bucket index.

    Hash collisions can lead to incorrect query results, severely affecting the usability of hash tables. To solve this problem, we expand the hash table whenever a hash collision occurs, until the collision is resolved. This method is simple and effective but inefficient due to the extensive data transfer and hash value computation involved in resizing the hash table. To improve efficiency, we can adopt the following strategies:

    1. Improve the data structure of the hash table, allowing it to function normally in the event of a hash collision.
    2. Only perform resizing when necessary, i.e., when hash collisions are severe.

    There are mainly two methods for improving the structure of hash tables: \"Separate Chaining\" and \"Open Addressing\".

    "},{"location":"chapter_hashing/hash_collision/#621-separate-chaining","title":"6.2.1 \u00a0 Separate Chaining","text":"

    In the original hash table, each bucket can store only one key-value pair. \"Separate chaining\" transforms individual elements into a linked list, with key-value pairs as list nodes, storing all colliding key-value pairs in the same list. The Figure 6-5 shows an example of a hash table with separate chaining.

    Figure 6-5 \u00a0 Separate Chaining Hash Table

    The operations of a hash table implemented with separate chaining have changed as follows:

    • Querying Elements: Input key, pass through the hash function to obtain the bucket index, access the head node of the list, then traverse the list and compare key to find the target key-value pair.
    • Adding Elements: First access the list head node via the hash function, then add the node (key-value pair) to the list.
    • Deleting Elements: Access the list head based on the hash function's result, then traverse the list to find and remove the target node.

    Separate chaining has the following limitations:

    • Increased Space Usage: The linked list contains node pointers, which consume more memory space than arrays.
    • Reduced Query Efficiency: Due to the need for linear traversal of the list to find the corresponding element.

    The code below provides a simple implementation of a separate chaining hash table, with two things to note:

    • Lists (dynamic arrays) are used instead of linked lists for simplicity. In this setup, the hash table (array) contains multiple buckets, each of which is a list.
    • This implementation includes a method for resizing the hash table. When the load factor exceeds \\(\\frac{2}{3}\\), we resize the hash table to twice its original size.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map_chaining.py
    class HashMapChaining:\n    \"\"\"\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\n        self.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\n        self.load_thres = 2.0 / 3.0  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        self.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\n        self.buckets = [[] for _ in range(self.capacity)]  # \u6876\u6570\u7ec4\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -> float:\n        \"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -> str | None:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        return None\n\n    def 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\n        if self.load_factor() > self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n        # \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        buckets = self.buckets\n        # \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -> \" + pair.val)\n            print(res)\n
    hash_map_chaining.cpp
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n  private:\n    int size;                       // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;                   // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres;               // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;                // \u6269\u5bb9\u500d\u6570\n    vector<vector<Pair *>> buckets; // \u6876\u6570\u7ec4\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~HashMapChaining() {\n        for (auto &bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // \u91ca\u653e\u5185\u5b58\n                delete pair;\n            }\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        int index = hashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (Pair *pair : buckets[index]) {\n            if (pair->key == key) {\n                return pair->val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n        return \"\";\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (Pair *pair : buckets[index]) {\n            if (pair->key == key) {\n                pair->val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &bucket = buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (int i = 0; i < bucket.size(); i++) {\n            if (bucket[i]->key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n                delete tmp;                       // \u91ca\u653e\u5185\u5b58\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        vector<vector<Pair *>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (auto &bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair->key, pair->val);\n                // \u91ca\u653e\u5185\u5b58\n                delete pair;\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (auto &bucket : buckets) {\n            cout << \"[\";\n            for (Pair *pair : bucket) {\n                cout << pair->key << \" -> \" << pair->val << \", \";\n            }\n            cout << \"]\\n\";\n        }\n    }\n};\n
    hash_map_chaining.java
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio; // \u6269\u5bb9\u500d\u6570\n    List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList<>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.add(new ArrayList<>());\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    String get(int key) {\n        int index = hashFunc(key);\n        List<Pair> bucket = buckets.get(index);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, String val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List<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\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List<Pair> bucket = buckets.get(index);\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        List<List<Pair>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new ArrayList<>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.add(new ArrayList<>());\n        }\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (List<Pair> bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (List<Pair> bucket : buckets) {\n            List<String> res = new ArrayList<>();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -> \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n
    hash_map_chaining.cs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio; // \u6269\u5bb9\u500d\u6570\n    List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List<List<Pair>>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (LoadFactor() > loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void Extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        List<List<Pair>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new List<List<Pair>>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        foreach (List<Pair> bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (List<Pair> bucket in buckets) {\n            List<string> res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -> \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n
    hash_map_chaining.go
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntype hashMapChaining struct {\n    size        int      // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity    int      // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    loadThres   float64  // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extendRatio int      // \u6269\u5bb9\u500d\u6570\n    buckets     [][]pair // \u6876\u6570\u7ec4\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i < 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n    return \"\"\n}\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\n    if m.loadFactor() > m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // \u5207\u7247\u5220\u9664\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i < len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i < m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -> \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n
    hash_map_chaining.swift
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    var loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    var extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: [[Pair]] // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    func hashFunc(key: Int) -> Int {\n        key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    func loadFactor() -> Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de nil\n        return nil\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if loadFactor() > loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    func extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -> \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n
    hash_map_chaining.js
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    #size; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio; // \u6269\u5bb9\u500d\u6570\n    #buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key, val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (let i = 0; i < bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -> ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n
    hash_map_chaining.ts
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    #size: number; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity: number; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres: number; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio: number; // \u6269\u5bb9\u500d\u6570\n    #buckets: Pair[][]; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key: number, val: string): void {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (let i = 0; i < bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend(): void {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -> ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n
    hash_map_chaining.dart
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n  late int size; // \u952e\u503c\u5bf9\u6570\u91cf\n  late int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n  late double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n  late int extendRatio; // \u6269\u5bb9\u500d\u6570\n  late List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) => []);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* \u8d1f\u8f7d\u56e0\u5b50 */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List<Pair> bucket = buckets[index];\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n    return null;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor() > loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List<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\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List<Pair> bucket = buckets[index];\n    // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n  void extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    List<List<Pair>> bucketsTmp = buckets;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) => []);\n    size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (List<Pair> bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (List<Pair> bucket in buckets) {\n      List<String> res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -> ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n
    hash_map_chaining.rs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nstruct HashMapChaining {\n    size: i32,\n    capacity: i32,\n    load_thres: f32,\n    extend_ratio: i32,\n    buckets: Vec<Vec<Pair>>,\n}\n\nimpl HashMapChaining {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new() -> Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        key as usize % self.capacity as usize\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fn load_factor(&self) -> f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fn remove(&mut self, key: i32) -> Option<String> {\n        let index = self.hash_func(key);\n        let bucket = &mut self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for i in 0..bucket.len() {\n            if bucket[i].key == key {\n                let pair = bucket.remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        None\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fn extend(&mut self) {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let buckets_tmp = std::mem::replace(&mut self.buckets, vec![]);\n\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fn print(&self) {\n        for bucket in &self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -> {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fn put(&mut self, key: i32, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if self.load_factor() > self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n        let bucket = &mut self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val.clone();\n                return;\n            }\n        }\n        let bucket = &mut self.buckets[index];\n\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        let pair = Pair {\n            key,\n            val: val.clone(),\n        };\n        bucket.push(pair);\n        self.size += 1;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fn get(&self, key: i32) -> Option<&str> {\n        let index = self.hash_func(key);\n        let bucket = &self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket {\n            if pair.key == key {\n                return Some(&pair.val);\n            }\n        }\n\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        None\n    }\n}\n
    hash_map_chaining.c
    /* \u94fe\u8868\u8282\u70b9 */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntypedef struct {\n    int size;         // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;  // \u6269\u5bb9\u500d\u6570\n    Node **buckets;   // \u6876\u6570\u7ec4\n} HashMapChaining;\n\n/* \u6784\u9020\u51fd\u6570 */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap->size = 0;\n    hashMap->capacity = 4;\n    hashMap->loadThres = 2.0 / 3.0;\n    hashMap->extendRatio = 2;\n    hashMap->buckets = (Node **)malloc(hashMap->capacity * sizeof(Node *));\n    for (int i = 0; i < hashMap->capacity; i++) {\n        hashMap->buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Node *cur = hashMap->buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur->next;\n            free(tmp->pair);\n            free(tmp);\n        }\n    }\n    free(hashMap->buckets);\n    free(hashMap);\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap->capacity;\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap->size / (double)hashMap->capacity;\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    Node *cur = hashMap->buckets[index];\n    while (cur) {\n        if (cur->pair->key == key) {\n            return cur->pair->val;\n        }\n        cur = cur->next;\n    }\n    return \"\"; // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor(hashMap) > hashMap->loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n    Node *cur = hashMap->buckets[index];\n    while (cur) {\n        if (cur->pair->key == key) {\n            strcpy(cur->pair->val, val); // \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n            return;\n        }\n        cur = cur->next;\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair->key = key;\n    strcpy(newPair->val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode->pair = newPair;\n    newNode->next = hashMap->buckets[index];\n    hashMap->buckets[index] = newNode;\n    hashMap->size++;\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend(HashMapChaining *hashMap) {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    int oldCapacity = hashMap->capacity;\n    Node **oldBuckets = hashMap->buckets;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    hashMap->capacity *= hashMap->extendRatio;\n    hashMap->buckets = (Node **)malloc(hashMap->capacity * sizeof(Node *));\n    for (int i = 0; i < hashMap->capacity; i++) {\n        hashMap->buckets[i] = NULL;\n    }\n    hashMap->size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (int i = 0; i < oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur->pair->key, cur->pair->val);\n            Node *temp = cur;\n            cur = cur->next;\n            // \u91ca\u653e\u5185\u5b58\n            free(temp->pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap->buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur->pair->key == key) {\n            // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n            if (pre) {\n                pre->next = cur->next;\n            } else {\n                hashMap->buckets[index] = cur->next;\n            }\n            // \u91ca\u653e\u5185\u5b58\n            free(cur->pair);\n            free(cur);\n            hashMap->size--;\n            return;\n        }\n        pre = cur;\n        cur = cur->next;\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Node *cur = hashMap->buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -> %s, \", cur->pair->key, cur->pair->val);\n            cur = cur->next;\n        }\n        printf(\"]\\n\");\n    }\n}\n
    hash_map_chaining.kt
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining() {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    val loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    val extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: MutableList<MutableList<Pair>> // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = ArrayList(capacity)\n        for (i in 0..<capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (pair in bucket) {\n            if (pair.key == key) return pair.value\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair.value = value\n                return\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        val pair = Pair(key, value)\n        bucket.add(pair)\n        size++\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fun extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        val bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        // mutablelist \u65e0\u56fa\u5b9a\u5927\u5c0f\n        buckets = mutableListOf()\n        for (i in 0..<capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair.value)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf<String>()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair.value\n                res.add(\"$k -> $v\")\n            }\n            println(res)\n        }\n    }\n}\n
    hash_map_chaining.rb
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.zig
    [class]{HashMapChaining}-[func]{}\n
    Code Visualization

    Full Screen >

    It's worth noting that when the list is very long, the query efficiency \\(O(n)\\) is poor. At this point, the list can be converted to an \"AVL tree\" or \"Red-Black tree\" to optimize the time complexity of the query operation to \\(O(\\log n)\\).

    "},{"location":"chapter_hashing/hash_collision/#622-open-addressing","title":"6.2.2 \u00a0 Open Addressing","text":"

    \"Open addressing\" does not introduce additional data structures but uses \"multiple probes\" to handle hash collisions. The probing methods mainly include linear probing, quadratic probing, and double hashing.

    Let's use linear probing as an example to introduce the mechanism of open addressing hash tables.

    "},{"location":"chapter_hashing/hash_collision/#1-linear-probing","title":"1. \u00a0 Linear Probing","text":"

    Linear probing uses a fixed-step linear search for probing, differing from ordinary hash tables.

    • Inserting Elements: Calculate the bucket index using the hash function. If the bucket already contains an element, linearly traverse forward from the conflict position (usually with a step size of \\(1\\)) until an empty bucket is found, then insert the element.
    • Searching for Elements: If a hash collision is found, use the same step size to linearly traverse forward until the corresponding element is found and return value; if an empty bucket is encountered, it means the target element is not in the hash table, so return None.

    The Figure 6-6 shows the distribution of key-value pairs in an open addressing (linear probing) hash table. According to this hash function, keys with the same last two digits will be mapped to the same bucket. Through linear probing, they are stored consecutively in that bucket and the buckets below it.

    Figure 6-6 \u00a0 Distribution of Key-Value Pairs in Open Addressing (Linear Probing) Hash Table

    However, linear probing tends to create \"clustering\". Specifically, the longer a continuous position in the array is occupied, the more likely these positions are to encounter hash collisions, further promoting the growth of these clusters and eventually leading to deterioration in the efficiency of operations.

    It's important to note that we cannot directly delete elements in an open addressing hash table. Deleting an element creates an empty bucket None in the array. When searching for elements, if linear probing encounters this empty bucket, it will return, making the elements below this bucket inaccessible. The program may incorrectly assume these elements do not exist, as shown in the Figure 6-7 .

    Figure 6-7 \u00a0 Query Issues Caused by Deletion in Open Addressing

    To solve this problem, we can use a \"lazy deletion\" mechanism: instead of directly removing elements from the hash table, use a constant TOMBSTONE to mark the bucket. In this mechanism, both None and TOMBSTONE represent empty buckets and can hold key-value pairs. However, when linear probing encounters TOMBSTONE, it should continue traversing since there may still be key-value pairs below it.

    However, lazy deletion may accelerate the degradation of hash table performance. Every deletion operation produces a delete mark, and as TOMBSTONE increases, so does the search time, as linear probing may have to skip multiple TOMBSTONE to find the target element.

    Therefore, consider recording the index of the first TOMBSTONE encountered during linear probing and swapping the target element found with this TOMBSTONE. The advantage of this is that each time a query or addition is performed, the element is moved to a bucket closer to the ideal position (starting point of probing), thereby optimizing the query efficiency.

    The code below implements an open addressing (linear probing) hash table with lazy deletion. To make fuller use of the hash table space, we treat the hash table as a \"circular array,\" continuing to traverse from the beginning when the end of the array is passed.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map_open_addressing.py
    class HashMapOpenAddressing:\n    \"\"\"\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\n        self.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\n        self.load_thres = 2.0 / 3.0  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        self.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\n        self.buckets: list[Pair | None] = [None] * self.capacity  # \u6876\u6570\u7ec4\n        self.TOMBSTONE = Pair(-1, \"-1\")  # \u5220\u9664\u6807\u8bb0\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -> float:\n        \"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -> int:\n        \"\"\"\u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while self.buckets[index] is not None:\n            # \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if self.buckets[index].key == key:\n                # \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                return index  # \u8fd4\u56de\u6876\u7d22\u5f15\n            # \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % self.capacity\n        # \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -> str:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de None\n        return None\n\n    def 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\n        if self.load_factor() > self.load_thres:\n            self.extend()\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n        # \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        buckets_tmp = self.buckets\n        # \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"->\", pair.val)\n
    hash_map_open_addressing.cpp
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity = 4;                     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    const double loadThres = 2.0 / 3.0;     // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    const int extendRatio = 2;            // \u6269\u5bb9\u500d\u6570\n    vector<Pair *> buckets;               // \u6876\u6570\u7ec4\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr && pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != nullptr) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index]->key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            return buckets[index]->val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n        return \"\";\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            buckets[index]->val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        vector<Pair *> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = vector<Pair *>(capacity, nullptr);\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr && pair != TOMBSTONE) {\n                put(pair->key, pair->val);\n                delete pair;\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout << \"nullptr\" << endl;\n            } else if (pair == TOMBSTONE) {\n                cout << \"TOMBSTONE\" << endl;\n            } else {\n                cout << pair->key << \" -> \" << pair->val << endl;\n            }\n        }\n    }\n};\n
    hash_map_open_addressing.java
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    private int capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private final double loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private final int extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n    private Pair[] buckets; // \u6876\u6570\u7ec4\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index].key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public String get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void put(int key, String val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    private void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        Pair[] bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (Pair pair : bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -> \" + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.cs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n    Pair[] buckets; // \u6876\u6570\u7ec4\n    Pair TOMBSTONE = new(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index].key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (LoadFactor() > loadThres) {\n            Extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void Extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        Pair[] bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -> \" + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.go
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\ntype hashMapOpenAddressing struct {\n    size        int     // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity    int     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    loadThres   float64 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extendRatio int     // \u6269\u5bb9\u500d\u6570\n    buckets     []*pair // \u6876\u6570\u7ec4\n    TOMBSTONE   *pair   // \u5220\u9664\u6807\u8bb0\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &pair{-1, \"-1\"},\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // \u6839\u636e\u952e\u8ba1\u7b97\u54c8\u5e0c\u503c\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // \u8ba1\u7b97\u5f53\u524d\u8d1f\u8f7d\u56e0\u5b50\n}\n\n/* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // \u83b7\u53d6\u521d\u59cb\u7d22\u5f15\n    firstTombstone := -1     // \u8bb0\u5f55\u9047\u5230\u7684\u7b2c\u4e00\u4e2aTOMBSTONE\u7684\u4f4d\u7f6e\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n            }\n            return index // \u8fd4\u56de\u627e\u5230\u7684\u7d22\u5f15\n        }\n        if firstTombstone == -1 && h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\u7684\u4f4d\u7f6e\n        }\n        index = (index + 1) % h.capacity // \u7ebf\u6027\u63a2\u6d4b\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    }\n    return \"\" // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de \"\"\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() > h.loadThres {\n        h.extend() // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    }\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &pair{key, val} // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        h.size++\n    } else {\n        h.buckets[index].val = val // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val\n    }\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        h.size--\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    h.capacity *= h.extendRatio           // \u66f4\u65b0\u5bb9\u91cf\n    h.buckets = make([]*pair, h.capacity) // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    h.size = 0                            // \u91cd\u7f6e\u5927\u5c0f\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for _, pair := range oldBuckets {\n        if pair != nil && pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -> %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n
    hash_map_open_addressing.swift
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    var loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    var extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: [Pair?] // \u6876\u6570\u7ec4\n    var TOMBSTONE: Pair // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    func hashFunc(key: Int) -> Int {\n        key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    func loadFactor() -> Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    func findBucket(key: Int) -> Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while buckets[index] != nil {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if buckets[index]!.key == key {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if firstTombstone == -1 && buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return nil\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if loadFactor() > loadThres {\n            extend()\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    func extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -> \\(pair!.val)\")\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.js
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    #size; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio; // \u6269\u5bb9\u500d\u6570\n    #buckets; // \u6876\u6570\u7ec4\n    #TOMBSTONE; // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0; // \u952e\u503c\u5bf9\u6570\u91cf\n        this.#capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n        this.#loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        this.#extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n        this.#buckets = Array(this.#capacity).fill(null); // \u6876\u6570\u7ec4\n        this.#TOMBSTONE = new Pair(-1, '-1'); // \u5220\u9664\u6807\u8bb0\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (this.#buckets[index] !== null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (this.#buckets[index].key === key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (\n                firstTombstone === -1 &&\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % this.#capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key, val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const pair of bucketsTmp) {\n            if (pair !== null && pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -> ' + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.ts
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private size: number; // \u952e\u503c\u5bf9\u6570\u91cf\n    private capacity: number; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private loadThres: number; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private extendRatio: number; // \u6269\u5bb9\u500d\u6570\n    private buckets: Array<Pair | null>; // \u6876\u6570\u7ec4\n    private TOMBSTONE: Pair; // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.size = 0; // \u952e\u503c\u5bf9\u6570\u91cf\n        this.capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n        this.loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        this.extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n        this.buckets = Array(this.capacity).fill(null); // \u6876\u6570\u7ec4\n        this.TOMBSTONE = new Pair(-1, '-1'); // \u5220\u9664\u6807\u8bb0\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (this.buckets[index] !== null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (this.buckets[index]!.key === key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (\n                firstTombstone === -1 &&\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % this.capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key: number): string | null {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key: number, val: string): void {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.loadFactor() > this.loadThres) {\n            this.extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key: number): void {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    private extend(): void {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const pair of bucketsTmp) {\n            if (pair !== null && pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -> ' + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.dart
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n  late int _size; // \u952e\u503c\u5bf9\u6570\u91cf\n  int _capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n  double _loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n  int _extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n  late List<Pair?> _buckets; // \u6876\u6570\u7ec4\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) => null);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* \u8d1f\u8f7d\u56e0\u5b50 */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n    while (_buckets[index] != null) {\n      // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n      if (_buckets[index]!.key == key) {\n        // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n        }\n        return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n      }\n      // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n      if (firstTombstone == -1 && _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n      index = (index + 1) % _capacity;\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n    return null;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor() > _loadThres) {\n      extend();\n    }\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n  void extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    List<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\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null && pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -> ${pair.val}\");\n      }\n    }\n  }\n}\n
    hash_map_open_addressing.rs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nstruct HashMapOpenAddressing {\n    size: usize,                // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity: usize,            // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    load_thres: f64,            // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extend_ratio: usize,        // \u6269\u5bb9\u500d\u6570\n    buckets: Vec<Option<Pair>>, // \u6876\u6570\u7ec4\n    TOMBSTONE: Option<Pair>,    // \u5220\u9664\u6807\u8bb0\n}\n\nimpl HashMapOpenAddressing {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new() -> Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fn load_factor(&self) -> f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    fn find_bucket(&mut self, key: i32) -> usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while self.buckets[index].is_some() {\n            // \u82e5\u9047\u5230 key\uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u5efa\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if first_tombstone == -1 && self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % self.capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fn get(&mut self, key: i32) -> Option<&str> {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &pair.val as &str);\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        None\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fn put(&mut self, key: i32, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if self.load_factor() > self.load_thres {\n            self.extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fn remove(&mut self, key: i32) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fn extend(&mut self) {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let buckets_tmp = self.buckets.clone();\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fn print(&self) {\n        for pair in &self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -> {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.c
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\ntypedef struct {\n    int size;         // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;  // \u6269\u5bb9\u500d\u6570\n    Pair **buckets;   // \u6876\u6570\u7ec4\n    Pair *TOMBSTONE;  // \u5220\u9664\u6807\u8bb0\n} HashMapOpenAddressing;\n\n/* \u6784\u9020\u51fd\u6570 */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap->size = 0;\n    hashMap->capacity = 4;\n    hashMap->loadThres = 2.0 / 3.0;\n    hashMap->extendRatio = 2;\n    hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);\n    hashMap->TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap->TOMBSTONE->key = -1;\n    hashMap->TOMBSTONE->val = \"-1\";\n\n    return hashMap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Pair *pair = hashMap->buckets[i];\n        if (pair != NULL && pair != hashMap->TOMBSTONE) {\n            free(pair->val);\n            free(pair);\n        }\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap->capacity;\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap->size / (double)hashMap->capacity;\n}\n\n/* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n    while (hashMap->buckets[index] != NULL) {\n        // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        if (hashMap->buckets[index]->key == key) {\n            // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n            if (firstTombstone != -1) {\n                hashMap->buckets[firstTombstone] = hashMap->buckets[index];\n                hashMap->buckets[index] = hashMap->TOMBSTONE;\n                return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n            }\n            return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n        }\n        // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n        if (firstTombstone == -1 && hashMap->buckets[index] == hashMap->TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n        index = (index + 1) % hashMap->capacity;\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        return hashMap->buckets[index]->val;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n    return \"\";\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor(hashMap) > hashMap->loadThres) {\n        extend(hashMap);\n    }\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        free(hashMap->buckets[index]->val);\n        hashMap->buckets[index]->val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap->buckets[index]->val, val);\n        hashMap->buckets[index]->val[strlen(val)] = '\\0';\n        return;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair->key = key;\n    pair->val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair->val, val);\n    pair->val[strlen(val)] = '\\0';\n\n    hashMap->buckets[index] = pair;\n    hashMap->size++;\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        Pair *pair = hashMap->buckets[index];\n        free(pair->val);\n        free(pair);\n        hashMap->buckets[index] = hashMap->TOMBSTONE;\n        hashMap->size--;\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    Pair **bucketsTmp = hashMap->buckets;\n    int oldCapacity = hashMap->capacity;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    hashMap->capacity *= hashMap->extendRatio;\n    hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);\n    hashMap->size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (int i = 0; i < oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL && pair != hashMap->TOMBSTONE) {\n            put(hashMap, pair->key, pair->val);\n            free(pair->val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Pair *pair = hashMap->buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap->TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -> %s\\n\", pair->key, pair->val);\n        }\n    }\n}\n
    hash_map_open_addressing.kt
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private var size: Int = 0 // \u952e\u503c\u5bf9\u6570\u91cf\n    private var capacity = 4 // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private val loadThres: Double = 2.0 / 3.0 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private val extendRatio = 2 // \u6269\u5bb9\u500d\u6570\n    private var buckets: Array<Pair?> // \u6876\u6570\u7ec4\n    private val TOMBSTONE = Pair(-1, \"-1\") // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init {\n        buckets = arrayOfNulls(capacity)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index]?.key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index]?.value\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend()\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index]!!.value = value\n            return\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = Pair(key, value)\n        size++\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fun extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        val bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (pair in bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                put(pair.key, pair.value)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -> ${pair.value}\")\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.rb
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.zig
    [class]{HashMapOpenAddressing}-[func]{}\n
    "},{"location":"chapter_hashing/hash_collision/#2-quadratic-probing","title":"2. \u00a0 Quadratic Probing","text":"

    Quadratic probing is similar to linear probing and is one of the common strategies of open addressing. When a collision occurs, quadratic probing does not simply skip a fixed number of steps but skips \"the square of the number of probes,\" i.e., \\(1, 4, 9, \\dots\\) steps.

    Quadratic probing has the following advantages:

    • Quadratic probing attempts to alleviate the clustering effect of linear probing by skipping the distance of the square of the number of probes.
    • Quadratic probing skips larger distances to find empty positions, helping to distribute data more evenly.

    However, quadratic probing is not perfect:

    • Clustering still exists, i.e., some positions are more likely to be occupied than others.
    • Due to the growth of squares, quadratic probing may not probe the entire hash table, meaning it might not access empty buckets even if they exist in the hash table.
    "},{"location":"chapter_hashing/hash_collision/#3-double-hashing","title":"3. \u00a0 Double Hashing","text":"

    As the name suggests, the double hashing method uses multiple hash functions \\(f_1(x)\\), \\(f_2(x)\\), \\(f_3(x)\\), \\(\\dots\\) for probing.

    • Inserting Elements: If hash function \\(f_1(x)\\) encounters a conflict, try \\(f_2(x)\\), and so on, until an empty position is found and the element is inserted.
    • Searching for Elements: Search in the same order of hash functions until the target element is found and returned; if an empty position is encountered or all hash functions have been tried, it indicates the element is not in the hash table, then return None.

    Compared to linear probing, double hashing is less prone to clustering but involves additional computation for multiple hash functions.

    Tip

    Please note that open addressing (linear probing, quadratic probing, and double hashing) hash tables all have the issue of \"not being able to directly delete elements.\"

    "},{"location":"chapter_hashing/hash_collision/#623-choice-of-programming-languages","title":"6.2.3 \u00a0 Choice of Programming Languages","text":"

    Various programming languages have adopted different hash table implementation strategies, here are a few examples:

    • Python uses open addressing. The dict dictionary uses pseudo-random numbers for probing.
    • Java uses separate chaining. Since JDK 1.8, when the array length in HashMap reaches 64 and the length of a linked list reaches 8, the linked list is converted to a red-black tree to improve search performance.
    • Go uses separate chaining. Go stipulates that each bucket can store up to 8 key-value pairs, and if the capacity is exceeded, an overflow bucket is connected; when there are too many overflow buckets, a special equal-size expansion operation is performed to ensure performance.
    "},{"location":"chapter_hashing/hash_map/","title":"6.1 \u00a0 Hash Table","text":"

    A \"hash table\", also known as a \"hash map\", achieves efficient element querying by establishing a mapping between keys and values. Specifically, when we input a key into the hash table, we can retrieve the corresponding value in \\(O(1)\\) time.

    As shown in the Figure 6-1 , given \\(n\\) students, each with two pieces of data: \"name\" and \"student number\". If we want to implement a query feature that returns the corresponding name when given a student number, we can use the hash table shown in the Figure 6-1 .

    Figure 6-1 \u00a0 Abstract representation of a hash table

    Apart from hash tables, arrays and linked lists can also be used to implement querying functions. Their efficiency is compared in the Table 6-1 .

    • Adding Elements: Simply add the element to the end of the array (or linked list), using \\(O(1)\\) time.
    • Querying Elements: Since the array (or linked list) is unordered, it requires traversing all the elements, using \\(O(n)\\) time.
    • Deleting Elements: First, locate the element, then delete it from the array (or linked list), using \\(O(n)\\) time.

    Table 6-1 \u00a0 Comparison of Element Query Efficiency

    Array Linked List Hash Table Find Element \\(O(n)\\) \\(O(n)\\) \\(O(1)\\) Add Element \\(O(1)\\) \\(O(1)\\) \\(O(1)\\) Delete Element \\(O(n)\\) \\(O(n)\\) \\(O(1)\\)

    Observations reveal that the time complexity for adding, deleting, and querying in a hash table is \\(O(1)\\), which is highly efficient.

    "},{"location":"chapter_hashing/hash_map/#611-common-operations-of-hash-table","title":"6.1.1 \u00a0 Common Operations of Hash Table","text":"

    Common operations of a hash table include initialization, querying, adding key-value pairs, and deleting key-value pairs, etc. Example code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig hash_map.py
    # Initialize hash table\nhmap: dict = {}\n\n# Add operation\n# Add key-value pair (key, value) to the hash table\nhmap[12836] = \"Xiao Ha\"\nhmap[15937] = \"Xiao Luo\"\nhmap[16750] = \"Xiao Suan\"\nhmap[13276] = \"Xiao Fa\"\nhmap[10583] = \"Xiao Ya\"\n\n# Query operation\n# Input key into hash table, get value\nname: str = hmap[15937]\n\n# Delete operation\n# Delete key-value pair (key, value) from hash table\nhmap.pop(10583)\n
    hash_map.cpp
    /* Initialize hash table */\nunordered_map<int, string> map;\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap[12836] = \"Xiao Ha\";\nmap[15937] = \"Xiao Luo\";\nmap[16750] = \"Xiao Suan\";\nmap[13276] = \"Xiao Fa\";\nmap[10583] = \"Xiao Ya\";\n\n/* Query operation */\n// Input key into hash table, get value\nstring name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.erase(10583);\n
    hash_map.java
    /* Initialize hash table */\nMap<Integer, String> map = new HashMap<>();\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap.put(12836, \"Xiao Ha\");   \nmap.put(15937, \"Xiao Luo\");   \nmap.put(16750, \"Xiao Suan\");   \nmap.put(13276, \"Xiao Fa\");\nmap.put(10583, \"Xiao Ya\");\n\n/* Query operation */\n// Input key into hash table, get value\nString name = map.get(15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583);\n
    hash_map.cs
    /* Initialize hash table */\nDictionary<int, string> map = new() {\n    /* Add operation */\n    // Add key-value pair (key, value) to the hash table\n    { 12836, \"Xiao Ha\" },\n    { 15937, \"Xiao Luo\" },\n    { 16750, \"Xiao Suan\" },\n    { 13276, \"Xiao Fa\" },\n    { 10583, \"Xiao Ya\" }\n};\n\n/* Query operation */\n// Input key into hash table, get value\nstring name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.Remove(10583);\n
    hash_map_test.go
    /* Initialize hash table */\nhmap := make(map[int]string)\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nhmap[12836] = \"Xiao Ha\"\nhmap[15937] = \"Xiao Luo\"\nhmap[16750] = \"Xiao Suan\"\nhmap[13276] = \"Xiao Fa\"\nhmap[10583] = \"Xiao Ya\"\n\n/* Query operation */\n// Input key into hash table, get value\nname := hmap[15937]\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\ndelete(hmap, 10583)\n
    hash_map.swift
    /* Initialize hash table */\nvar map: [Int: String] = [:]\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap[12836] = \"Xiao Ha\"\nmap[15937] = \"Xiao Luo\"\nmap[16750] = \"Xiao Suan\"\nmap[13276] = \"Xiao Fa\"\nmap[10583] = \"Xiao Ya\"\n\n/* Query operation */\n// Input key into hash table, get value\nlet name = map[15937]!\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.removeValue(forKey: 10583)\n
    hash_map.js
    /* Initialize hash table */\nconst map = new Map();\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap.set(12836, 'Xiao Ha');\nmap.set(15937, 'Xiao Luo');\nmap.set(16750, 'Xiao Suan');\nmap.set(13276, 'Xiao Fa');\nmap.set(10583, 'Xiao Ya');\n\n/* Query operation */\n// Input key into hash table, get value\nlet name = map.get(15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.delete(10583);\n
    hash_map.ts
    /* Initialize hash table */\nconst map = new Map<number, string>();\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap.set(12836, 'Xiao Ha');\nmap.set(15937, 'Xiao Luo');\nmap.set(16750, 'Xiao Suan');\nmap.set(13276, 'Xiao Fa');\nmap.set(10583, 'Xiao Ya');\nconsole.info('\\nAfter adding, the hash table is\\nKey -> Value');\nconsole.info(map);\n\n/* Query operation */\n// Input key into hash table, get value\nlet name = map.get(15937);\nconsole.info('\\nInput student number 15937, query name ' + name);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.delete(10583);\nconsole.info('\\nAfter deleting 10583, the hash table is\\nKey -> Value');\nconsole.info(map);\n
    hash_map.dart
    /* Initialize hash table */\nMap<int, String> map = {};\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap[12836] = \"Xiao Ha\";\nmap[15937] = \"Xiao Luo\";\nmap[16750] = \"Xiao Suan\";\nmap[13276] = \"Xiao Fa\";\nmap[10583] = \"Xiao Ya\";\n\n/* Query operation */\n// Input key into hash table, get value\nString name = map[15937];\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nmap.remove(10583);\n
    hash_map.rs
    use std::collections::HashMap;\n\n/* Initialize hash table */\nlet mut map: HashMap<i32, String> = HashMap::new();\n\n/* Add operation */\n// Add key-value pair (key, value) to the hash table\nmap.insert(12836, \"Xiao Ha\".to_string());\nmap.insert(15937, \"Xiao Luo\".to_string());\nmap.insert(16750, \"Xiao Suan\".to_string());\nmap.insert(13279, \"Xiao Fa\".to_string());\nmap.insert(10583, \"Xiao Ya\".to_string());\n\n/* Query operation */\n// Input key into hash table, get value\nlet _name: Option<&String> = map.get(&15937);\n\n/* Delete operation */\n// Delete key-value pair (key, value) from hash table\nlet _removed_value: Option<String> = map.remove(&10583);\n
    hash_map.c
    // C does not provide a built-in hash table\n
    hash_map.kt
    \n
    hash_map.zig
    \n
    Code Visualization

    Full Screen >

    There are three common ways to traverse a hash table: traversing key-value pairs, keys, and values. Example code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig hash_map.py
    # Traverse hash table\n# Traverse key-value pairs key->value\nfor key, value in hmap.items():\n    print(key, \"->\", value)\n# Traverse keys only\nfor key in hmap.keys():\n    print(key)\n# Traverse values only\nfor value in hmap.values():\n    print(value)\n
    hash_map.cpp
    /* Traverse hash table */\n// Traverse key-value pairs key->value\nfor (auto kv: map) {\n    cout << kv.first << \" -> \" << kv.second << endl;\n}\n// Traverse using iterator key->value\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout << iter->first << \"->\" << iter->second << endl;\n}\n
    hash_map.java
    /* Traverse hash table */\n// Traverse key-value pairs key->value\nfor (Map.Entry<Integer, String> kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -> \" + kv.getValue());\n}\n// Traverse keys only\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// Traverse values only\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n
    hash_map.cs
    /* Traverse hash table */\n// Traverse key-value pairs Key->Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -> \" + kv.Value);\n}\n// Traverse keys only\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// Traverse values only\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n
    hash_map_test.go
    /* Traverse hash table */\n// Traverse key-value pairs key->value\nfor key, value := range hmap {\n    fmt.Println(key, \"->\", value)\n}\n// Traverse keys only\nfor key := range hmap {\n    fmt.Println(key)\n}\n// Traverse values only\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n
    hash_map.swift
    /* Traverse hash table */\n// Traverse key-value pairs Key->Value\nfor (key, value) in map {\n    print(\"\\(key) -> \\(value)\")\n}\n// Traverse keys only\nfor key in map.keys {\n    print(key)\n}\n// Traverse values only\nfor value in map.values {\n    print(value)\n}\n
    hash_map.js
    /* Traverse hash table */\nconsole.info('\\nTraverse key-value pairs Key->Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -> ' + v);\n}\nconsole.info('\\nTraverse keys only Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nTraverse values only Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n
    hash_map.ts
    /* Traverse hash table */\nconsole.info('\\nTraverse key-value pairs Key->Value');\nfor (const [k, v] of map.entries()) {\n    console.info(k + ' -> ' + v);\n}\nconsole.info('\\nTraverse keys only Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\nTraverse values only Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n
    hash_map.dart
    /* Traverse hash table */\n// Traverse key-value pairs Key->Value\nmap.forEach((key, value) {\nprint('$key -> $value');\n});\n\n// Traverse keys only Key\nmap.keys.forEach((key) {\nprint(key);\n});\n\n// Traverse values only Value\nmap.values.forEach((value) {\nprint(value);\n});\n
    hash_map.rs
    /* Traverse hash table */\n// Traverse key-value pairs Key->Value\nfor (key, value) in &map {\n    println!(\"{key} -> {value}\");\n}\n\n// Traverse keys only Key\nfor key in map.keys() {\n    println!(\"{key}\"); \n}\n\n// Traverse values only Value\nfor value in map.values() {\n    println!(\"{value}\");\n}\n
    hash_map.c
    // C does not provide a built-in hash table\n
    hash_map.kt
    \n
    hash_map.zig
    // Zig example is not provided\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_hashing/hash_map/#612-simple-implementation-of-hash-table","title":"6.1.2 \u00a0 Simple Implementation of Hash Table","text":"

    First, let's consider the simplest case: implementing a hash table using just an array. In the hash table, each empty slot in the array is called a \"bucket\", and each bucket can store one key-value pair. Therefore, the query operation involves finding the bucket corresponding to the key and retrieving the value from it.

    So, how do we locate the appropriate bucket based on the key? This is achieved through a \"hash function\". The role of the hash function is to map a larger input space to a smaller output space. In a hash table, the input space is all possible keys, and the output space is all buckets (array indices). In other words, input a key, and we can use the hash function to determine the storage location of the corresponding key-value pair in the array.

    The calculation process of the hash function for a given key is divided into the following two steps:

    1. Calculate the hash value using a certain hash algorithm hash().
    2. Take the modulus of the hash value with the number of buckets (array length) capacity to obtain the array index index.
    index = hash(key) % capacity\n

    Afterward, we can use index to access the corresponding bucket in the hash table and thereby retrieve the value.

    Assuming array length capacity = 100 and hash algorithm hash(key) = key, the hash function is key % 100. The Figure 6-2 uses key as the student number and value as the name to demonstrate the working principle of the hash function.

    Figure 6-2 \u00a0 Working principle of hash function

    The following code implements a simple hash table. Here, we encapsulate key and value into a class Pair to represent the key-value pair.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_hash_map.py
    class Pair:\n    \"\"\"\u952e\u503c\u5bf9\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        # \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -> str:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        index: int = self.hash_func(key)\n        # \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\n        self.buckets[index] = None\n\n    def entry_set(self) -> list[Pair]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -> list[int]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u952e\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -> list[str]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u503c\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"->\", pair.val)\n
    array_hash_map.cpp
    /* \u952e\u503c\u5bf9 */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this->key = key;\n        this->val = val;\n    }\n};\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n  private:\n    vector<Pair *> buckets;\n\n  public:\n    ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = vector<Pair *>(100);\n    }\n\n    ~ArrayHashMap() {\n        // \u91ca\u653e\u5185\u5b58\n        for (const auto &bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair->val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // \u91ca\u653e\u5185\u5b58\u5e76\u7f6e\u4e3a nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    vector<Pair *> pairSet() {\n        vector<Pair *> pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    vector<int> keySet() {\n        vector<int> keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair->key);\n            }\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    vector<string> valueSet() {\n        vector<string> valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair->val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout << kv->key << \" -> \" << kv->val << endl;\n        }\n    }\n};\n
    array_hash_map.java
    /* \u952e\u503c\u5bf9 */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private List<Pair> buckets;\n\n    public ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = new ArrayList<>();\n        for (int i = 0; i < 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets.set(index, null);\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public List<Pair> pairSet() {\n        List<Pair> pairSet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public List<Integer> keySet() {\n        List<Integer> keySet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public List<String> valueSet() {\n        List<String> valueSet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -> \" + kv.val);\n        }\n    }\n}\n
    array_hash_map.cs
    /* \u952e\u503c\u5bf9 int->string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    List<Pair?> buckets;\n    public ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = [];\n        for (int i = 0; i < 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public List<Pair> PairSet() {\n        List<Pair> pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public List<int> KeySet() {\n        List<int> keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public List<string> ValueSet() {\n        List<string> valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -> \" + kv.val);\n        }\n    }\n}\n
    array_hash_map.go
    /* \u952e\u503c\u5bf9 */\ntype pair struct {\n    key int\n    val string\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nfunc newArrayHashMap() *arrayHashMap {\n    // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n    buckets := make([]*pair, 100)\n    return &arrayHashMap{buckets: buckets}\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\n    a.buckets[index] = nil\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e\u5bf9 */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* \u83b7\u53d6\u6240\u6709\u503c */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"->\", pair.val)\n        }\n    }\n}\n
    array_hash_map.swift
    /* \u952e\u503c\u5bf9 */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -> Bool {\n        lhs.key == rhs.key && lhs.val == rhs.val\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private func hashFunc(key: Int) -> Int {\n        let index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = nil\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    func pairSet() -> [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    func keySet() -> [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    func valueSet() -> [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -> \\(pair.val)\")\n        }\n    }\n}\n
    array_hash_map.js
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        this.#buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    entries() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    keys() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    values() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -> ${pair.val}`);\n        }\n    }\n}\n
    array_hash_map.ts
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        this.buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -> ${pair.val}`);\n        }\n    }\n}\n
    array_hash_map.dart
    /* \u952e\u503c\u5bf9 */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n  late List<Pair?> _buckets;\n\n  ArrayHashMap() {\n    // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n    _buckets = List.filled(100, null);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n  List<Pair> pairSet() {\n    List<Pair> pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u952e */\n  List<int> keySet() {\n    List<int> keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u503c */\n  List<String> values() {\n    List<String> valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -> ${kv.val}\");\n    }\n  }\n}\n
    array_hash_map.rs
    /* \u952e\u503c\u5bf9 */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\npub struct ArrayHashMap {\n    buckets: Vec<Option<Pair>>,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -> ArrayHashMap {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        key as usize % 100\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    pub fn get(&self, key: i32) -> Option<&String> {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &pair.val)\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    pub fn put(&mut self, key: i32, val: &str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    pub fn remove(&mut self, key: i32) {\n        let index = self.hash_func(key);\n        // \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\n        self.buckets[index] = None;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    pub fn entry_set(&self) -> Vec<&Pair> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    pub fn key_set(&self) -> Vec<&i32> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &pair.key))\n            .collect()\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    pub fn value_set(&self) -> Vec<&String> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &pair.val))\n            .collect()\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    pub fn print(&self) {\n        for pair in self.entry_set() {\n            println!(\"{} -> {}\", pair.key, pair.val);\n        }\n    }\n}\n
    array_hash_map.c
    /* \u952e\u503c\u5bf9 int->string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntypedef struct {\n    Pair *buckets[HASHTABLE_CAPACITY];\n} ArrayHashMap;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    return hmap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            free(hmap->buckets[i]->val);\n            free(hmap->buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair->key = key;\n    Pair->val = malloc(strlen(val) + 1);\n    strcpy(Pair->val, val);\n\n    int index = hashFunc(key);\n    hmap->buckets[index] = Pair;\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap->buckets[index]->val);\n    free(hmap->buckets[index]);\n    hmap->buckets[index] = NULL;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            entries[index].key = hmap->buckets[i]->key;\n            entries[index].val = malloc(strlen(hmap->buckets[i]->val) + 1);\n            strcpy(entries[index].val, hmap->buckets[i]->val);\n            index++;\n        }\n    }\n    set->set = entries;\n    set->len = total;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            keys[index] = hmap->buckets[i]->key;\n            index++;\n        }\n    }\n    set->set = keys;\n    set->len = total;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u503c */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            vals[index] = hmap->buckets[i]->val;\n            index++;\n        }\n    }\n    set->set = vals;\n    set->len = total;\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i < set.len; i++) {\n        printf(\"%d -> %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n
    array_hash_map.kt
    /* \u952e\u503c\u5bf9 */\nclass Pair(\n    var key: Int,\n    var value: String\n)\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private val buckets = arrayOfNulls<Pair>(100)\n\n    init {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        for (i in 0..<100) {\n            buckets[i] = null\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair.value\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        val pair = Pair(key, value)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    fun pairSet(): MutableList<Pair> {\n        val pairSet = ArrayList<Pair>()\n        for (pair in buckets) {\n            if (pair != null) pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    fun keySet(): MutableList<Int> {\n        val keySet = ArrayList<Int>()\n        for (pair in buckets) {\n            if (pair != null) keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    fun valueSet(): MutableList<String> {\n        val valueSet = ArrayList<String>()\n        for (pair in buckets) {\n            pair?.let { valueSet.add(it.value) }\n        }\n        return valueSet\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val value = kv.value\n            println(\"${key}->${value}\")\n        }\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private val buckets = arrayOfNulls<Pair>(100)\n\n    init {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        for (i in 0..<100) {\n            buckets[i] = null\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair.value\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        val pair = Pair(key, value)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    fun pairSet(): MutableList<Pair> {\n        val pairSet = ArrayList<Pair>()\n        for (pair in buckets) {\n            if (pair != null) pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    fun keySet(): MutableList<Int> {\n        val keySet = ArrayList<Int>()\n        for (pair in buckets) {\n            if (pair != null) keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    fun valueSet(): MutableList<String> {\n        val valueSet = ArrayList<String>()\n        for (pair in buckets) {\n            pair?.let { valueSet.add(it.value) }\n        }\n        return valueSet\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val value = kv.value\n            println(\"${key}->${value}\")\n        }\n    }\n}\n
    array_hash_map.rb
    [class]{Pair}-[func]{}\n\n[class]{ArrayHashMap}-[func]{}\n
    array_hash_map.zig
    // \u952e\u503c\u5bf9\nconst Pair = struct {\n    key: usize = undefined,\n    val: []const u8 = undefined,\n\n   pub fn init(key: usize, val: []const u8) Pair {\n        return Pair {\n            .key = key,\n            .val = val,\n        };\n    }\n};\n\n// \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\nfn ArrayHashMap(comptime T: type) type {\n    return struct {\n        bucket: ?std.ArrayList(?T) = null,\n        mem_allocator: std.mem.Allocator = undefined,\n\n        const Self = @This();\n\n        // \u6784\u9020\u51fd\u6570\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            self.mem_allocator = allocator;\n            // \u521d\u59cb\u5316\u4e00\u4e2a\u957f\u5ea6\u4e3a 100 \u7684\u6876\uff08\u6570\u7ec4\uff09\n            self.bucket = std.ArrayList(?T).init(self.mem_allocator);\n            var i: i32 = 0;\n            while (i < 100) : (i += 1) {\n                try self.bucket.?.append(null);\n            }\n        }\n\n        // \u6790\u6784\u51fd\u6570\n        pub fn deinit(self: *Self) void {\n            if (self.bucket != null) self.bucket.?.deinit();\n        }\n\n        // \u54c8\u5e0c\u51fd\u6570\n        fn hashFunc(key: usize) usize {\n            var index = key % 100;\n            return index;\n        }\n\n        // \u67e5\u8be2\u64cd\u4f5c\n        pub fn get(self: *Self, key: usize) []const u8 {\n            var index = hashFunc(key);\n            var pair = self.bucket.?.items[index];\n            return pair.?.val;\n        }\n\n        // \u6dfb\u52a0\u64cd\u4f5c\n        pub fn put(self: *Self, key: usize, val: []const u8) !void {\n            var pair = Pair.init(key, val);\n            var index = hashFunc(key);\n            self.bucket.?.items[index] = pair;\n        }\n\n        // \u5220\u9664\u64cd\u4f5c\n        pub fn remove(self: *Self, key: usize) !void {\n            var index = hashFunc(key);\n            // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n            self.bucket.?.items[index] = null;\n        }       \n\n        // \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\n        pub fn pairSet(self: *Self) !std.ArrayList(T) {\n            var entry_set = std.ArrayList(T).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try entry_set.append(item.?);\n            }\n            return entry_set;\n        }  \n\n        // \u83b7\u53d6\u6240\u6709\u952e\n        pub fn keySet(self: *Self) !std.ArrayList(usize) {\n            var key_set = std.ArrayList(usize).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try key_set.append(item.?.key);\n            }\n            return key_set;\n        }  \n\n        // \u83b7\u53d6\u6240\u6709\u503c\n        pub fn valueSet(self: *Self) !std.ArrayList([]const u8) {\n            var value_set = std.ArrayList([]const u8).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try value_set.append(item.?.val);\n            }\n            return value_set;\n        }\n\n        // \u6253\u5370\u54c8\u5e0c\u8868\n        pub fn print(self: *Self) !void {\n            var entry_set = try self.pairSet();\n            defer entry_set.deinit();\n            for (entry_set.items) |item| {\n                std.debug.print(\"{} -> {s}\\n\", .{item.key, item.val});\n            }\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_hashing/hash_map/#613-hash-collision-and-resizing","title":"6.1.3 \u00a0 Hash Collision and Resizing","text":"

    Fundamentally, the role of the hash function is to map the entire input space of all keys to the output space of all array indices. However, the input space is often much larger than the output space. Therefore, theoretically, there must be situations where \"multiple inputs correspond to the same output\".

    For the hash function in the above example, if the last two digits of the input key are the same, the output of the hash function will also be the same. For example, when querying for students with student numbers 12836 and 20336, we find:

    12836 % 100 = 36\n20336 % 100 = 36\n

    As shown in the Figure 6-3 , both student numbers point to the same name, which is obviously incorrect. This situation where multiple inputs correspond to the same output is known as \"hash collision\".

    Figure 6-3 \u00a0 Example of hash collision

    It is easy to understand that the larger the capacity \\(n\\) of the hash table, the lower the probability of multiple keys being allocated to the same bucket, and the fewer the collisions. Therefore, expanding the capacity of the hash table can reduce hash collisions.

    As shown in the Figure 6-4 , before expansion, key-value pairs (136, A) and (236, D) collided; after expansion, the collision is resolved.

    Figure 6-4 \u00a0 Hash table expansion

    Similar to array expansion, resizing a hash table requires migrating all key-value pairs from the original hash table to the new one, which is time-consuming. Furthermore, since the capacity capacity of the hash table changes, we need to recalculate the storage positions of all key-value pairs using the hash function, which adds to the computational overhead of the resizing process. Therefore, programming languages often reserve a sufficiently large capacity for the hash table to prevent frequent resizing.

    The \"load factor\" is an important concept for hash tables. It is defined as the ratio of the number of elements in the hash table to the number of buckets. It is used to measure the severity of hash collisions and is often used as a trigger for resizing the hash table. For example, in Java, when the load factor exceeds \\(0.75\\), the system will resize the hash table to twice its original size.

    "},{"location":"chapter_hashing/summary/","title":"6.4 \u00a0 Summary","text":""},{"location":"chapter_hashing/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"
    • Given an input key, a hash table can retrieve the corresponding value in \\(O(1)\\) time, which is highly efficient.
    • Common hash table operations include querying, adding key-value pairs, deleting key-value pairs, and traversing the hash table.
    • The hash function maps a key to an array index, allowing access to the corresponding bucket to retrieve the value.
    • Two different keys may end up with the same array index after hashing, leading to erroneous query results. This phenomenon is known as hash collision.
    • The larger the capacity of the hash table, the lower the probability of hash collisions. Therefore, hash table resizing can mitigate hash collisions. Similar to array resizing, hash table resizing is costly.
    • Load factor, defined as the ratio of the number of elements to the number of buckets in the hash table, reflects the severity of hash collisions and is often used as a trigger for resizing the hash table.
    • Chaining addresses hash collisions by converting each element into a linked list, storing all colliding elements in the same list. However, excessively long lists can reduce query efficiency, which can be improved by converting the lists into red-black trees.
    • Open addressing handles hash collisions through multiple probes. Linear probing uses a fixed step size but cannot delete elements and is prone to clustering. Multiple hashing uses several hash functions for probing, making it less susceptible to clustering but increasing computational load.
    • Different programming languages adopt various hash table implementations. For example, Java's HashMap uses chaining, while Python's dict employs open addressing.
    • In hash tables, we desire hash algorithms with determinism, high efficiency, and uniform distribution. In cryptography, hash algorithms should also possess collision resistance and the avalanche effect.
    • Hash algorithms typically use large prime numbers as moduli to ensure uniform distribution of hash values and reduce hash collisions.
    • Common hash algorithms include MD5, SHA-1, SHA-2, and SHA-3. MD5 is often used for file integrity checks, while SHA-2 is commonly used in secure applications and protocols.
    • Programming languages usually provide built-in hash algorithms for data types to calculate bucket indices in hash tables. Generally, only immutable objects are hashable.
    "},{"location":"chapter_hashing/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: When does the time complexity of a hash table degrade to \\(O(n)\\)?

    The time complexity of a hash table can degrade to \\(O(n)\\) when hash collisions are severe. When the hash function is well-designed, the capacity is set appropriately, and collisions are evenly distributed, the time complexity is \\(O(1)\\). We usually consider the time complexity to be \\(O(1)\\) when using built-in hash tables in programming languages.

    Q: Why not use the hash function \\(f(x) = x\\)? This would eliminate collisions.

    Under the hash function \\(f(x) = x\\), each element corresponds to a unique bucket index, which is equivalent to an array. However, the input space is usually much larger than the output space (array length), so the last step of a hash function is often to take the modulo of the array length. In other words, the goal of a hash table is to map a larger state space to a smaller one while providing \\(O(1)\\) query efficiency.

    Q: Why can hash tables be more efficient than arrays, linked lists, or binary trees, even though they are implemented using these structures?

    Firstly, hash tables have higher time efficiency but lower space efficiency. A significant portion of memory in hash tables remains unused.

    Secondly, they are only more efficient in specific use cases. If a feature can be implemented with the same time complexity using an array or a linked list, it's usually faster than using a hash table. This is because the computation of the hash function incurs overhead, making the constant factor in the time complexity larger.

    Lastly, the time complexity of hash tables can degrade. For example, in chaining, we perform search operations in a linked list or red-black tree, which still risks degrading to \\(O(n)\\) time.

    Q: Does multiple hashing also have the flaw of not being able to delete elements directly? Can space marked as deleted be reused?

    Multiple hashing is a form of open addressing, and all open addressing methods have the drawback of not being able to delete elements directly; they require marking elements as deleted. Marked spaces can be reused. When inserting new elements into the hash table, and the hash function points to a position marked as deleted, that position can be used by the new element. This maintains the probing sequence of the hash table while ensuring efficient use of space.

    Q: Why do hash collisions occur during the search process in linear probing?

    During the search process, the hash function points to the corresponding bucket and key-value pair. If the key doesn't match, it indicates a hash collision. Therefore, linear probing will search downwards at a predetermined step size until the correct key-value pair is found or the search fails.

    Q: Why can resizing a hash table alleviate hash collisions?

    The last step of a hash function often involves taking the modulo of the array length \\(n\\), to keep the output within the array index range. When resizing, the array length \\(n\\) changes, and the indices corresponding to the keys may also change. Keys that were previously mapped to the same bucket might be distributed across multiple buckets after resizing, thereby mitigating hash collisions.

    "},{"location":"chapter_heap/","title":"Chapter 8. \u00a0 Heap","text":"

    Abstract

    The heap is like mountain peaks, stacked and undulating, each with its unique shape.

    Among these peaks, the highest one always catches the eye first.

    "},{"location":"chapter_heap/#chapter-contents","title":"Chapter Contents","text":"
    • 8.1 \u00a0 Heap
    • 8.2 \u00a0 Building a Heap
    • 8.3 \u00a0 Top-k Problem
    • 8.4 \u00a0 Summary
    "},{"location":"chapter_heap/build_heap/","title":"8.2 \u00a0 Heap construction operation","text":"

    In some cases, we want to build a heap using all elements of a list, and this process is known as \"heap construction operation.\"

    "},{"location":"chapter_heap/build_heap/#821-implementing-with-heap-insertion-operation","title":"8.2.1 \u00a0 Implementing with heap insertion operation","text":"

    First, we create an empty heap and then iterate through the list, performing the \"heap insertion operation\" on each element in turn. This means adding the element to the end of the heap and then \"heapifying\" it from bottom to top.

    Each time an element is added to the heap, the length of the heap increases by one. Since nodes are added to the binary tree from top to bottom, the heap is constructed \"from top to bottom.\"

    Let the number of elements be \\(n\\), and each element's insertion operation takes \\(O(\\log{n})\\) time, thus the time complexity of this heap construction method is \\(O(n \\log n)\\).

    "},{"location":"chapter_heap/build_heap/#822-implementing-by-heapifying-through-traversal","title":"8.2.2 \u00a0 Implementing by heapifying through traversal","text":"

    In fact, we can implement a more efficient method of heap construction in two steps.

    1. Add all elements of the list as they are into the heap, at this point the properties of the heap are not yet satisfied.
    2. Traverse the heap in reverse order (reverse of level-order traversal), and perform \"top to bottom heapify\" on each non-leaf node.

    After heapifying a node, the subtree with that node as the root becomes a valid sub-heap. Since the traversal is in reverse order, the heap is built \"from bottom to top.\"

    The reason for choosing reverse traversal is that it ensures the subtree below the current node is already a valid sub-heap, making the heapification of the current node effective.

    It's worth mentioning that since leaf nodes have no children, they naturally form valid sub-heaps and do not need to be heapified. As shown in the following code, the last non-leaf node is the parent of the last node; we start from it and traverse in reverse order to perform heapification:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    self.max_heap = nums\n    # \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\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\n    maxHeap = nums;\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (int i = parent(size() - 1); i >= 0; i--) {\n        siftDown(i);\n    }\n}\n
    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\n    maxHeap = new ArrayList<>(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (int i = parent(size() - 1); i >= 0; i--) {\n        siftDown(i);\n    }\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\n    maxHeap = new List<int>(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i >= 0; i--) {\n        SiftDown(i);\n    }\n}\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\n    h := &maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i >= 0; i-- {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        h.siftDown(i)\n    }\n    return h\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\n    maxHeap = nums\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\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\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (let i = this.#parent(this.size() - 1); i >= 0; i--) {\n        this.#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\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (let i = this.parent(this.size() - 1); i >= 0; i--) {\n        this.siftDown(i);\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\n  for (int i = _parent(size() - 1); i >= 0; i--) {\n    siftDown(i);\n  }\n}\n
    my_heap.rs
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nfn new(nums: Vec<i32>) -> Self {\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    let mut heap = MaxHeap { max_heap: nums };\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\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\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap->size = size;\n    memcpy(maxHeap->data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i >= 0; i--) {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n
    my_heap.kt
    /* \u5927\u9876\u5806 */\nclass MaxHeap(nums: List<Int>?) {\n    // \u4f7f\u7528\u5217\u8868\u800c\u975e\u6570\u7ec4\uff0c\u8fd9\u6837\u65e0\u987b\u8003\u8651\u6269\u5bb9\u95ee\u9898\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    private val maxHeap = ArrayList(nums!!)\n\n    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\n    init {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u4ea4\u6362\u5143\u7d20 */\n    private fun swap(i: Int, j: Int) {\n        maxHeap[i] = maxHeap[j].also { maxHeap[j] = maxHeap[i] }\n    }\n\n    /* \u83b7\u53d6\u5806\u5927\u5c0f */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n        return size() == 0\n    }\n\n    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* \u5143\u7d20\u5165\u5806 */\n    fun push(value: Int) {\n        // \u6dfb\u52a0\u8282\u70b9\n        maxHeap.add(value)\n        // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n        siftUp(size() - 1)\n    }\n\n    /* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\n    private fun siftUp(it: Int) {\n        // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n        var i = it\n        while (true) {\n            // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n            val p = parent(i)\n            // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n            if (p < 0 || maxHeap[i] <= maxHeap[p]) break\n            // \u4ea4\u6362\u4e24\u8282\u70b9\n            swap(i, p)\n            // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n            i = p\n        }\n    }\n\n    /* \u5143\u7d20\u51fa\u5806 */\n    fun pop(): Int {\n        // \u5224\u7a7a\u5904\u7406\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        swap(0, size() - 1)\n        // \u5220\u9664\u8282\u70b9\n        val value = maxHeap.removeAt(size() - 1)\n        // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n        siftDown(0)\n        // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n        return value\n    }\n\n    /* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\n    private fun siftDown(it: Int) {\n        // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n        var i = it\n        while (true) {\n            // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l\n            if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r\n            // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n            if (ma == i) break\n            // \u4ea4\u6362\u4e24\u8282\u70b9\n            swap(i, ma)\n            // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n            i = ma\n        }\n    }\n\n    /* \u6253\u5370\u5806\uff08\u4e8c\u53c9\u6811\uff09 */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -> b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{__init__}\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 {\n    if (self.max_heap != null) return;\n    self.max_heap = std.ArrayList(T).init(allocator);\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    try self.max_heap.?.appendSlice(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    var i: usize = parent(self.size() - 1) + 1;\n    while (i > 0) : (i -= 1) {\n        try self.siftDown(i - 1);\n    }\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_heap/build_heap/#823-complexity-analysis","title":"8.2.3 \u00a0 Complexity analysis","text":"

    Next, let's attempt to calculate the time complexity of this second method of heap construction.

    • Assuming the number of nodes in the complete binary tree is \\(n\\), then the number of leaf nodes is \\((n + 1) / 2\\), where \\(/\\) is integer division. Therefore, the number of nodes that need to be heapified is \\((n - 1) / 2\\).
    • In the process of \"top to bottom heapification,\" each node is heapified to the leaf nodes at most, so the maximum number of iterations is the height of the binary tree \\(\\log n\\).

    Multiplying the two, we get the time complexity of the heap construction process as \\(O(n \\log n)\\). But this estimate is not accurate, because it does not take into account the nature of the binary tree having far more nodes at the lower levels than at the top.

    Let's perform a more accurate calculation. To simplify the calculation, assume a \"perfect binary tree\" with \\(n\\) nodes and height \\(h\\); this assumption does not affect the correctness of the result.

    Figure 8-5 \u00a0 Node counts at each level of a perfect binary tree

    As shown in the Figure 8-5 , the maximum number of iterations for a node \"to be heapified from top to bottom\" is equal to the distance from that node to the leaf nodes, which is precisely \"node height.\" Therefore, we can sum the \"number of nodes \\(\\times\\) node height\" at each level, to get the total number of heapification iterations for all nodes.

    \\[ T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{(h-1)}\\times1 \\]

    To simplify the above equation, we need to use knowledge of sequences from high school, first multiply \\(T(h)\\) by \\(2\\), to get:

    \\[ \\begin{aligned} T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^h\\times1 \\newline \\end{aligned} \\]

    By subtracting \\(T(h)\\) from \\(2T(h)\\) using the method of displacement, we get:

    \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 2^{h-1} + 2^h \\]

    Observing the equation, \\(T(h)\\) is an geometric series, which can be directly calculated using the sum formula, resulting in a time complexity of:

    \\[ \\begin{aligned} T(h) & = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline & = 2^{h+1} - h - 2 \\newline & = O(2^h) \\end{aligned} \\]

    Further, a perfect binary tree with height \\(h\\) has \\(n = 2^{h+1} - 1\\) nodes, thus the complexity is \\(O(2^h) = O(n)\\). This calculation shows that the time complexity of inputting a list and constructing a heap is \\(O(n)\\), which is very efficient.

    "},{"location":"chapter_heap/heap/","title":"8.1 \u00a0 Heap","text":"

    A \"heap\" is a complete binary tree that satisfies specific conditions and can be mainly divided into two types, as shown in the Figure 8-1 .

    • \"Min heap\": The value of any node \\(\\leq\\) the values of its child nodes.
    • \"Max heap\": The value of any node \\(\\geq\\) the values of its child nodes.

    Figure 8-1 \u00a0 Min heap and max heap

    As a special case of a complete binary tree, heaps have the following characteristics:

    • The bottom layer nodes are filled from left to right, and nodes in other layers are fully filled.
    • The root node of the binary tree is called the \"heap top,\" and the bottom-rightmost node is called the \"heap bottom.\"
    • For max heaps (min heaps), the value of the heap top element (root node) is the largest (smallest).
    "},{"location":"chapter_heap/heap/#811-common-operations-on-heaps","title":"8.1.1 \u00a0 Common operations on heaps","text":"

    It should be noted that many programming languages provide a \"priority queue,\" which is an abstract data structure defined as a queue with priority sorting.

    In fact, heaps are often used to implement priority queues, with max heaps equivalent to priority queues where elements are dequeued in descending order. From a usage perspective, we can consider \"priority queue\" and \"heap\" as equivalent data structures. Therefore, this book does not make a special distinction between the two, uniformly referring to them as \"heap.\"

    Common operations on heaps are shown in the Table 8-1 , and the method names depend on the programming language.

    Table 8-1 \u00a0 Efficiency of Heap Operations

    Method name Description Time complexity push() Add an element to the heap \\(O(\\log n)\\) pop() Remove the top element from the heap \\(O(\\log n)\\) peek() Access the top element (for max/min heap, the max/min value) \\(O(1)\\) size() Get the number of elements in the heap \\(O(1)\\) isEmpty() Check if the heap is empty \\(O(1)\\)

    In practice, we can directly use the heap class (or priority queue class) provided by programming languages.

    Similar to sorting algorithms where we have \"ascending order\" and \"descending order,\" we can switch between \"min heap\" and \"max heap\" by setting a flag or modifying the Comparator. The code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig heap.py
    # \u521d\u59cb\u5316\u5c0f\u9876\u5806\nmin_heap, flag = [], 1\n# \u521d\u59cb\u5316\u5927\u9876\u5806\nmax_heap, flag = [], -1\n\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\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\n# \u83b7\u53d6\u5806\u9876\u5143\u7d20\npeek: int = flag * max_heap[0] # 5\n\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\n# \u83b7\u53d6\u5806\u5927\u5c0f\nsize: int = len(max_heap)\n\n# \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = not max_heap\n\n# \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\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\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.top(); // 5\n\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\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.empty();\n\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.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\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.peek(); // 5\n\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.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));\n
    heap.cs
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nPriorityQueue<int, int> minHeap = new();\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(Comparer<int>.Create((x, y) => y - x));\n\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\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.Peek();//5\n\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\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.Count;\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.Count == 0;\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<int, int>([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\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\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\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\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\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\n    return (*h)[i].(int) > (*h)[j].(int)\n}\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\n// Top \u83b7\u53d6\u5806\u9876\u5143\u7d20\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* \u521d\u59cb\u5316\u5806 */\n    // \u521d\u59cb\u5316\u5927\u9876\u5806\n    maxHeap := &intHeap{}\n    heap.Init(maxHeap)\n    /* \u5143\u7d20\u5165\u5806 */\n    // \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u6dfb\u52a0\u5143\u7d20\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\n    top := maxHeap.Top()\n    fmt.Printf(\"\u5806\u9876\u5143\u7d20\u4e3a %d\\n\", top)\n\n    /* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n    // \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u79fb\u9664\u5143\u7d20\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* \u83b7\u53d6\u5806\u5927\u5c0f */\n    size := len(*maxHeap)\n    fmt.Printf(\"\u5806\u5143\u7d20\u6570\u91cf\u4e3a %d\\n\", size)\n\n    /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"\u5806\u662f\u5426\u4e3a\u7a7a %t\\n\", isEmpty)\n}\n
    heap.swift
    /* \u521d\u59cb\u5316\u5806 */\n// Swift \u7684 Heap \u7c7b\u578b\u540c\u65f6\u652f\u6301\u6700\u5927\u5806\u548c\u6700\u5c0f\u5806\uff0c\u4e14\u9700\u8981\u5f15\u5165 swift-collections\nvar heap = Heap<Int>()\n\n/* \u5143\u7d20\u5165\u5806 */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nvar peek = heap.max()!\n\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nlet size = heap.count\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = heap.isEmpty\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n
    heap.js
    // JavaScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.ts
    // TypeScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.dart
    // Dart \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.rs
    use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nlet mut min_heap = BinaryHeap::<Reverse<i32>>::new();\n// \u521d\u59cb\u5316\u5927\u9876\u5806\nlet mut max_heap = BinaryHeap::new();\n\n/* \u5143\u7d20\u5165\u5806 */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nlet size = max_heap.len();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = max_heap.is_empty();\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n
    heap.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.kt
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nvar minHeap = PriorityQueue<Int>()\n// \u521d\u59cb\u5316\u5927\u9876\u5806\uff08\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\u4fee\u6539 Comparator \u5373\u53ef\uff09\nval maxHeap = PriorityQueue { a: Int, b: Int -> b - a }\n\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nvar peek = maxHeap.peek() // 5\n\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.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nval size = maxHeap.size\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = maxHeap.isEmpty()\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n
    heap.rb
    \n
    heap.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    https://pythontutor.com/render.html#code=import%20heapq%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20min_heap,%20flag%20%3D%20%5B%5D,%201%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20max_heap,%20flag%20%3D%20%5B%5D,%20-1%0A%20%20%20%20%0A%20%20%20%20%23%20Python%20%E7%9A%84%20heapq%20%E6%A8%A1%E5%9D%97%E9%BB%98%E8%AE%A4%E5%AE%9E%E7%8E%B0%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E8%80%83%E8%99%91%E5%B0%86%E2%80%9C%E5%85%83%E7%B4%A0%E5%8F%96%E8%B4%9F%E2%80%9D%E5%90%8E%E5%86%8D%E5%85%A5%E5%A0%86%EF%BC%8C%E8%BF%99%E6%A0%B7%E5%B0%B1%E5%8F%AF%E4%BB%A5%E5%B0%86%E5%A4%A7%E5%B0%8F%E5%85%B3%E7%B3%BB%E9%A2%A0%E5%80%92%EF%BC%8C%E4%BB%8E%E8%80%8C%E5%AE%9E%E7%8E%B0%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E5%9C%A8%E6%9C%AC%E7%A4%BA%E4%BE%8B%E4%B8%AD%EF%BC%8Cflag%20%3D%201%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%B0%8F%E9%A1%B6%E5%A0%86%EF%BC%8Cflag%20%3D%20-1%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%201%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%203%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%202%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%205%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%204%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20flag%20*%20max_heap%5B0%5D%20%23%205%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%E5%87%BA%E5%A0%86%0A%20%20%20%20%23%20%E5%87%BA%E5%A0%86%E5%85%83%E7%B4%A0%E4%BC%9A%E5%BD%A2%E6%88%90%E4%B8%80%E4%B8%AA%E4%BB%8E%E5%A4%A7%E5%88%B0%E5%B0%8F%E7%9A%84%E5%BA%8F%E5%88%97%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%205%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%204%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%203%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%202%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%201%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E5%A4%A7%E5%B0%8F%0A%20%20%20%20size%20%3D%20len%28max_heap%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%A0%86%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20not%20max_heap%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%BE%93%E5%85%A5%E5%88%97%E8%A1%A8%E5%B9%B6%E5%BB%BA%E5%A0%86%0A%20%20%20%20min_heap%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20heapq.heapify%28min_heap%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false

    "},{"location":"chapter_heap/heap/#812-implementation-of-heaps","title":"8.1.2 \u00a0 Implementation of heaps","text":"

    The following implementation is of a max heap. To convert it into a min heap, simply invert all size logic comparisons (for example, replace \\(\\geq\\) with \\(\\leq\\)). Interested readers are encouraged to implement it on their own.

    "},{"location":"chapter_heap/heap/#1-storage-and-representation-of-heaps","title":"1. \u00a0 Storage and representation of heaps","text":"

    As mentioned in the \"Binary Trees\" section, complete binary trees are well-suited for array representation. Since heaps are a type of complete binary tree, we will use arrays to store heaps.

    When using an array to represent a binary tree, elements represent node values, and indexes represent node positions in the binary tree. Node pointers are implemented through an index mapping formula.

    As shown in the Figure 8-2 , given an index \\(i\\), the index of its left child is \\(2i + 1\\), the index of its right child is \\(2i + 2\\), and the index of its parent is \\((i - 1) / 2\\) (floor division). When the index is out of bounds, it signifies a null node or the node does not exist.

    Figure 8-2 \u00a0 Representation and storage of heaps

    We can encapsulate the index mapping formula into functions for convenient later use:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def left(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return (i - 1) // 2  # \u5411\u4e0b\u6574\u9664\n
    my_heap.cpp
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.java
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.cs
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint Parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.go
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) parent(i int) int {\n    // \u5411\u4e0b\u6574\u9664\n    return (i - 1) / 2\n}\n
    my_heap.swift
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc left(i: Int) -> Int {\n    2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc right(i: Int) -> Int {\n    2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc parent(i: Int) -> Int {\n    (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.js
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.ts
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.dart
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.rs
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfn left(i: usize) -> usize {\n    2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfn right(i: usize) -> usize {\n    2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfn parent(i: usize) -> usize {\n    (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.c
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2;\n}\n
    my_heap.kt
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{left}\n\n[class]{MaxHeap}-[func]{right}\n\n[class]{MaxHeap}-[func]{parent}\n
    my_heap.zig
    // \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\nfn left(i: usize) usize {\n    return 2 * i + 1;\n}\n\n// \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\nfn right(i: usize) usize {\n    return 2 * i + 2;\n}\n\n// \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15\nfn parent(i: usize) usize {\n    // return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n    return @divFloor(i - 1, 2);\n}\n
    "},{"location":"chapter_heap/heap/#2-accessing-the-top-element-of-the-heap","title":"2. \u00a0 Accessing the top element of the heap","text":"

    The top element of the heap is the root node of the binary tree, which is also the first element of the list:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def peek(self) -> int:\n    \"\"\"\u8bbf\u95ee\u5806\u9876\u5143\u7d20\"\"\"\n    return self.max_heap[0]\n
    my_heap.cpp
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n    return maxHeap[0];\n}\n
    my_heap.java
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n    return maxHeap.get(0);\n}\n
    my_heap.cs
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint Peek() {\n    return maxHeap[0];\n}\n
    my_heap.go
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n
    my_heap.swift
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc peek() -> Int {\n    maxHeap[0]\n}\n
    my_heap.js
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek() {\n    return this.#maxHeap[0];\n}\n
    my_heap.ts
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek(): number {\n    return this.maxHeap[0];\n}\n
    my_heap.dart
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n  return _maxHeap[0];\n}\n
    my_heap.rs
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfn peek(&self) -> Option<i32> {\n    self.max_heap.first().copied()\n}\n
    my_heap.c
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap->data[0];\n}\n
    my_heap.kt
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfun peek(): Int {\n    return maxHeap[0]\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{peek}\n
    my_heap.zig
    // \u8bbf\u95ee\u5806\u9876\u5143\u7d20\nfn peek(self: *Self) T {\n    return self.max_heap.?.items[0];\n}  \n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_heap/heap/#3-inserting-an-element-into-the-heap","title":"3. \u00a0 Inserting an element into the heap","text":"

    Given an element val, we first add it to the bottom of the heap. After addition, since val may be larger than other elements in the heap, the heap's integrity might be compromised, thus it's necessary to repair the path from the inserted node to the root node. This operation is called \"heapifying\".

    Considering starting from the node inserted, perform heapify from bottom to top. As shown in the Figure 8-3 , we compare the value of the inserted node with its parent node, and if the inserted node is larger, we swap them. Then continue this operation, repairing each node in the heap from bottom to top until passing the root node or encountering a node that does not need to be swapped.

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

    Figure 8-3 \u00a0 Steps of element insertion into the heap

    Given a total of \\(n\\) nodes, the height of the tree is \\(O(\\log n)\\). Hence, the loop iterations for the heapify operation are at most \\(O(\\log n)\\), making the time complexity of the element insertion operation \\(O(\\log n)\\). The code is as shown:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def push(self, val: int):\n    \"\"\"\u5143\u7d20\u5165\u5806\"\"\"\n    # \u6dfb\u52a0\u8282\u70b9\n    self.max_heap.append(val)\n    # \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\"\"\"\n    while True:\n        # \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        p = self.parent(i)\n        # \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 or self.max_heap[i] <= self.max_heap[p]:\n            break\n        # \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, p)\n        # \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n
    my_heap.cpp
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.push_back(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p])\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap[i], maxHeap[p]);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.java
    /* \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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.cs
    /* \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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid SiftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = Parent(i);\n        // \u82e5\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p])\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        Swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.go
    /* \u5143\u7d20\u5165\u5806 */\nfunc (h *maxHeap) push(val any) {\n    // \u6dfb\u52a0\u8282\u70b9\n    h.data = append(h.data, val)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    h.siftUp(len(h.data) - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        p := h.parent(i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 || h.data[i].(int) <= h.data[p].(int) {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        h.swap(i, p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.swift
    /* \u5143\u7d20\u5165\u5806 */\nfunc push(val: Int) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.append(val)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(i: size() - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        let p = parent(i: i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 || maxHeap[i] <= maxHeap[p] {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i: i, j: p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.js
    /* \u5143\u7d20\u5165\u5806 */\npush(val) {\n    // \u6dfb\u52a0\u8282\u70b9\n    this.#maxHeap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    this.#siftUp(this.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\n#siftUp(i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        const p = this.#parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.#swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.ts
    /* \u5143\u7d20\u5165\u5806 */\npush(val: number): void {\n    // \u6dfb\u52a0\u8282\u70b9\n    this.maxHeap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    this.siftUp(this.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nsiftUp(i: number): void {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        const p = this.parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = 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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n  while (true) {\n    // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n    int p = _parent(i);\n    // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n    if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {\n      break;\n    }\n    // \u4ea4\u6362\u4e24\u8282\u70b9\n    _swap(i, p);\n    // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n    i = p;\n  }\n}\n
    my_heap.rs
    /* \u5143\u7d20\u5165\u5806 */\nfn push(&mut self, val: i32) {\n    // \u6dfb\u52a0\u8282\u70b9\n    self.max_heap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    self.sift_up(self.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfn sift_up(&mut self, mut i: usize) {\n    loop {\n        // \u8282\u70b9 i \u5df2\u7ecf\u662f\u5806\u9876\u8282\u70b9\u4e86\uff0c\u7ed3\u675f\u5806\u5316\n        if i == 0 {\n            break;\n        }\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        let p = Self::parent(i);\n        // \u5f53\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if self.max_heap[i] <= self.max_heap[p] {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.c
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(MaxHeap *maxHeap, int val) {\n    // \u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u4e0d\u5e94\u8be5\u6dfb\u52a0\u8fd9\u4e48\u591a\u8282\u70b9\n    if (maxHeap->size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap->data[maxHeap->size] = val;\n    maxHeap->size++;\n\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(maxHeap, maxHeap->size - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(maxHeap, i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap->data[i] <= maxHeap->data[p]) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap, i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.kt
    /* \u5143\u7d20\u5165\u5806 */\nfun push(value: Int) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.add(value)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(size() - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfun siftUp(it: Int) {\n    // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n    var i = it\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        val p = parent(i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p]) break\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{push}\n\n[class]{MaxHeap}-[func]{sift_up}\n
    my_heap.zig
    // \u5143\u7d20\u5165\u5806\nfn push(self: *Self, val: T) !void {\n    // \u6dfb\u52a0\u8282\u70b9\n    try self.max_heap.?.append(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    try self.siftUp(self.size() - 1);\n}  \n\n// \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\nfn siftUp(self: *Self, i_: usize) !void {\n    var i = i_;\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        var p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        try self.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_heap/heap/#4-removing-the-top-element-from-the-heap","title":"4. \u00a0 Removing the top element from the heap","text":"

    The top element of the heap is the root node of the binary tree, that is, the first element of the list. If we directly remove the first element from the list, all node indexes in the binary tree would change, making it difficult to use heapify for repairs subsequently. To minimize changes in element indexes, we use the following steps.

    1. Swap the top element with the bottom element of the heap (swap the root node with the rightmost leaf node).
    2. After swapping, remove the bottom of the heap from the list (note, since it has been swapped, what is actually being removed is the original top element).
    3. Starting from the root node, perform heapify from top to bottom.

    As shown in the Figure 8-4 , the direction of \"heapify from top to bottom\" is opposite to \"heapify from bottom to top\". We compare the value of the root node with its two children and swap it with the largest child. Then repeat this operation until passing the leaf node or encountering a node that does not need to be swapped.

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

    Figure 8-4 \u00a0 Steps of removing the top element from the heap

    Similar to the element insertion operation, the time complexity of the top element removal operation is also \\(O(\\log n)\\). The code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def pop(self) -> int:\n    \"\"\"\u5143\u7d20\u51fa\u5806\"\"\"\n    # \u5224\u7a7a\u5904\u7406\n    if self.is_empty():\n        raise IndexError(\"\u5806\u4e3a\u7a7a\")\n    # \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    self.swap(0, self.size() - 1)\n    # \u5220\u9664\u8282\u70b9\n    val = self.max_heap.pop()\n    # \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    self.sift_down(0)\n    # \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\"\"\"\n    while True:\n        # \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l < self.size() and self.max_heap[l] > self.max_heap[ma]:\n            ma = l\n        if r < self.size() and self.max_heap[r] > self.max_heap[ma]:\n            ma = r\n        # \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i:\n            break\n        # \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, ma)\n        # \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n
    my_heap.cpp
    /* \u5143\u7d20\u51fa\u5806 */\nvoid pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty()) {\n        throw out_of_range(\"\u5806\u4e3a\u7a7a\");\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // \u5220\u9664\u8282\u70b9\n    maxHeap.pop_back();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = left(i), r = right(i), ma = i;\n        if (l < size() && maxHeap[l] > maxHeap[ma])\n            ma = l;\n        if (r < size() && maxHeap[r] > maxHeap[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.java
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(0, size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap.remove(size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = left(i), r = right(i), ma = i;\n        if (l < size() && maxHeap.get(l) > maxHeap.get(ma))\n            ma = l;\n        if (r < size() && maxHeap.get(r) > maxHeap.get(ma))\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.cs
    /* \u5143\u7d20\u51fa\u5806 */\nint Pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    Swap(0, Size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    SiftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid SiftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = Left(i), r = Right(i), ma = i;\n        if (l < Size() && maxHeap[l] > maxHeap[ma])\n            ma = l;\n        if (r < Size() && maxHeap[r] > maxHeap[ma])\n            ma = r;\n        // \u82e5\u201c\u8282\u70b9 i \u6700\u5927\u201d\u6216\u201c\u8d8a\u8fc7\u53f6\u8282\u70b9\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\n        if (ma == i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        Swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.go
    /* \u5143\u7d20\u51fa\u5806 */\nfunc (h *maxHeap) pop() any {\n    // \u5224\u7a7a\u5904\u7406\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    h.swap(0, h.size()-1)\n    // \u5220\u9664\u8282\u70b9\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    h.siftDown(0)\n\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\n        l, r, max := h.left(i), h.right(i), i\n        if l < h.size() && h.data[l].(int) > h.data[max].(int) {\n            max = l\n        }\n        if r < h.size() && h.data[r].(int) > h.data[max].(int) {\n            max = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if max == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        h.swap(i, max)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = max\n    }\n}\n
    my_heap.swift
    /* \u5143\u7d20\u51fa\u5806 */\nfunc pop() -> Int {\n    // \u5224\u7a7a\u5904\u7406\n    if isEmpty() {\n        fatalError(\"\u5806\u4e3a\u7a7a\")\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(i: 0, j: size() - 1)\n    // \u5220\u9664\u8282\u70b9\n    let val = maxHeap.remove(at: size() - 1)\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(i: 0)\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l < size(), maxHeap[l] > maxHeap[ma] {\n            ma = l\n        }\n        if r < size(), maxHeap[r] > maxHeap[ma] {\n            ma = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i: i, j: ma)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\n}\n
    my_heap.js
    /* \u5143\u7d20\u51fa\u5806 */\npop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (this.isEmpty()) throw new Error('\u5806\u4e3a\u7a7a');\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    this.#swap(0, this.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    const val = this.#maxHeap.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    this.#siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\n#siftDown(i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.#swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.ts
    /* \u5143\u7d20\u51fa\u5806 */\npop(): number {\n    // \u5224\u7a7a\u5904\u7406\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    this.swap(0, this.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    const val = this.maxHeap.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    this.siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nsiftDown(i: number): void {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.dart
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n  // \u5224\u7a7a\u5904\u7406\n  if (isEmpty()) throw Exception('\u5806\u4e3a\u7a7a');\n  // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n  _swap(0, size() - 1);\n  // \u5220\u9664\u8282\u70b9\n  int val = _maxHeap.removeLast();\n  // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n  siftDown(0);\n  // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n  return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n  while (true) {\n    // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;\n    if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;\n    // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n    if (ma == i) break;\n    // \u4ea4\u6362\u4e24\u8282\u70b9\n    _swap(i, ma);\n    // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n    i = ma;\n  }\n}\n
    my_heap.rs
    /* \u5143\u7d20\u51fa\u5806 */\nfn pop(&mut self) -> i32 {\n    // \u5224\u7a7a\u5904\u7406\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    self.swap(0, self.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    let val = self.max_heap.remove(self.size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    self.sift_down(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfn sift_down(&mut self, mut i: usize) {\n    loop {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l < self.size() && self.max_heap[l] > self.max_heap[ma] {\n            ma = l;\n        }\n        if r < self.size() && self.max_heap[r] > self.max_heap[ma] {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.c
    /* \u5143\u7d20\u51fa\u5806 */\nint pop(MaxHeap *maxHeap) {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap->data[maxHeap->size - 1];\n    maxHeap->size--;\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(maxHeap, 0);\n\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l < size(maxHeap) && maxHeap->data[l] > maxHeap->data[max]) {\n            max = l;\n        }\n        if (r < size(maxHeap) && maxHeap->data[r] > maxHeap->data[max]) {\n            max = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (max == i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap, i, max);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = max;\n    }\n}\n
    my_heap.kt
    /* \u5143\u7d20\u51fa\u5806 */\nfun pop(): Int {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(0, size() - 1)\n    // \u5220\u9664\u8282\u70b9\n    val value = maxHeap.removeAt(size() - 1)\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0)\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return value\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfun siftDown(it: Int) {\n    // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n    var i = it\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l\n        if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) break\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, ma)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{pop}\n\n[class]{MaxHeap}-[func]{sift_down}\n
    my_heap.zig
    // \u5143\u7d20\u51fa\u5806\nfn pop(self: *Self) !T {\n    // \u5224\u65ad\u5904\u7406\n    if (self.isEmpty()) unreachable;\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    try self.swap(0, self.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    var val = self.max_heap.?.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    try self.siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n} \n\n// \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\nfn siftDown(self: *Self, i_: usize) !void {\n    var i = i_;\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        var l = left(i);\n        var r = right(i);\n        var ma = i;\n        if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        try self.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_heap/heap/#813-common-applications-of-heaps","title":"8.1.3 \u00a0 Common applications of heaps","text":"
    • Priority Queue: Heaps are often the preferred data structure for implementing priority queues, with both enqueue and dequeue operations having a time complexity of \\(O(\\log n)\\), and building a queue having a time complexity of \\(O(n)\\), all of which are very efficient.
    • Heap Sort: Given a set of data, we can create a heap from them and then continually perform element removal operations to obtain ordered data. However, we usually use a more elegant method to implement heap sort, as detailed in the \"Heap Sort\" section.
    • Finding the Largest \\(k\\) Elements: This is a classic algorithm problem and also a typical application, such as selecting the top 10 hot news for Weibo hot search, picking the top 10 selling products, etc.
    "},{"location":"chapter_heap/summary/","title":"8.4 \u00a0 Summary","text":""},{"location":"chapter_heap/summary/#1-key-review","title":"1. \u00a0 Key review","text":"
    • A heap is a complete binary tree, which can be divided into a max heap and a min heap based on its property. The top element of a max (min) heap is the largest (smallest).
    • A priority queue is defined as a queue with dequeue priority, usually implemented using a heap.
    • Common operations of a heap and their corresponding time complexities include: element insertion into the heap \\(O(\\log n)\\), removing the top element from the heap \\(O(\\log n)\\), and accessing the top element of the heap \\(O(1)\\).
    • A complete binary tree is well-suited to be represented by an array, thus heaps are commonly stored using arrays.
    • Heapify operations are used to maintain the properties of the heap and are used in both heap insertion and removal operations.
    • The time complexity of inserting \\(n\\) elements into a heap and building the heap can be optimized to \\(O(n)\\), which is highly efficient.
    • Top-k is a classic algorithm problem that can be efficiently solved using the heap data structure, with a time complexity of \\(O(n \\log k)\\).
    "},{"location":"chapter_heap/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Is the \"heap\" in data structures the same concept as the \"heap\" in memory management?

    The two are not the same concept, even though they are both referred to as \"heap\". The heap in computer system memory is part of dynamic memory allocation, where the program can use it to store data during execution. The program can request a certain amount of heap memory to store complex structures like objects and arrays. When these data are no longer needed, the program needs to release this memory to prevent memory leaks. Compared to stack memory, the management and usage of heap memory need to be more cautious, as improper use may lead to memory leaks and dangling pointers.

    "},{"location":"chapter_heap/top_k/","title":"8.3 \u00a0 Top-k problem","text":"

    Question

    Given an unordered array nums of length \\(n\\), return the largest \\(k\\) elements in the array.

    For this problem, we will first introduce two straightforward solutions, then explain a more efficient heap-based method.

    "},{"location":"chapter_heap/top_k/#831-method-1-iterative-selection","title":"8.3.1 \u00a0 Method 1: Iterative selection","text":"

    We can perform \\(k\\) rounds of iterations as shown in the Figure 8-6 , extracting the \\(1^{st}\\), \\(2^{nd}\\), \\(\\dots\\), \\(k^{th}\\) largest elements in each round, with a time complexity of \\(O(nk)\\).

    This method is only suitable when \\(k \\ll n\\), as the time complexity approaches \\(O(n^2)\\) when \\(k\\) is close to \\(n\\), which is very time-consuming.

    Figure 8-6 \u00a0 Iteratively finding the largest k elements

    Tip

    When \\(k = n\\), we can obtain a complete ordered sequence, which is equivalent to the \"selection sort\" algorithm.

    "},{"location":"chapter_heap/top_k/#832-method-2-sorting","title":"8.3.2 \u00a0 Method 2: Sorting","text":"

    As shown in the Figure 8-7 , we can first sort the array nums and then return the last \\(k\\) elements, with a time complexity of \\(O(n \\log n)\\).

    Clearly, this method \"overachieves\" the task, as we only need to find the largest \\(k\\) elements, without the need to sort the other elements.

    Figure 8-7 \u00a0 Sorting to find the largest k elements

    "},{"location":"chapter_heap/top_k/#833-method-3-heap","title":"8.3.3 \u00a0 Method 3: Heap","text":"

    We can solve the Top-k problem more efficiently based on heaps, as shown in the following process.

    1. Initialize a min heap, where the top element is the smallest.
    2. First, insert the first \\(k\\) elements of the array into the heap.
    3. Starting from the \\(k + 1^{th}\\) element, if the current element is greater than the top element of the heap, remove the top element of the heap and insert the current element into the heap.
    4. After completing the traversal, the heap contains the largest \\(k\\) elements.
    <1><2><3><4><5><6><7><8><9>

    Figure 8-8 \u00a0 Find the largest k elements based on heap

    Example code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    # \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    heap = []\n    # \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for 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\n        if nums[i] > heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\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) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    priority_queue<int, vector<int>, greater<int>> heap;\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.push(nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n
    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) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    Queue<Integer> heap = new PriorityQueue<Integer>();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.offer(nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n
    top_k.cs
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nPriorityQueue<int, int> TopKHeap(int[] nums, int k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    PriorityQueue<int, int> heap = new();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n
    top_k.go
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    h := &minHeap{}\n    heap.Init(h)\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for i := 0; i < k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for i := k; i < len(nums); 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\n        if nums[i] > h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\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    // \u521d\u59cb\u5316\u4e00\u4e2a\u5c0f\u9876\u5806\uff0c\u5e76\u5c06\u524d k \u4e2a\u5143\u7d20\u5efa\u5806\n    var heap = Heap(nums.prefix(k))\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for i in nums.indices.dropFirst(k) {\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\n        if nums[i] > heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n
    top_k.js
    /* \u5143\u7d20\u5165\u5806 */\nfunction pushMinHeap(maxHeap, val) {\n    // \u5143\u7d20\u53d6\u53cd\n    maxHeap.push(-val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nfunction popMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.pop();\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunction peekMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.peek();\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nfunction getMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return maxHeap.getMaxHeap().map((num) => -num);\n}\n\n/* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunction topKHeap(nums, k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    const maxHeap = new MaxHeap([]);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (let i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (let 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // \u8fd4\u56de\u5806\u4e2d\u5143\u7d20\n    return getMinHeap(maxHeap);\n}\n
    top_k.ts
    /* \u5143\u7d20\u5165\u5806 */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // \u5143\u7d20\u53d6\u53cd\n    maxHeap.push(-val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.pop();\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.peek();\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // \u5143\u7d20\u53d6\u53cd\n    return maxHeap.getMaxHeap().map((num: number) => -num);\n}\n\n/* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    const maxHeap = new MaxHeap([]);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (let i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (let 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // \u8fd4\u56de\u5806\u4e2d\u5143\u7d20\n    return getMinHeap(maxHeap);\n}\n
    top_k.dart
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nMinHeap topKHeap(List<int> nums, int k) {\n  // \u521d\u59cb\u5316\u5c0f\u9876\u5806\uff0c\u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n  for (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\n    if (nums[i] > heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n
    top_k.rs
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {\n    // BinaryHeap \u662f\u5927\u9876\u5806\uff0c\u4f7f\u7528 Reverse \u5c06\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u5b9e\u73b0\u5c0f\u9876\u5806\n    let mut heap = BinaryHeap::<Reverse<i32>>::new();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for &num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for &num in nums.iter().skip(k) {\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\n        if num > heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n
    top_k.c
    /* \u5143\u7d20\u5165\u5806 */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // \u5143\u7d20\u53d6\u53cd\n    push(maxHeap, -val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nint popMinHeap(MaxHeap *maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -pop(maxHeap);\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -peek(maxHeap);\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // \u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\u5e76\u5b58\u5165 res \u6570\u7ec4\n    int *res = (int *)malloc(maxHeap->size * sizeof(int));\n    for (int i = 0; i < maxHeap->size; i++) {\n        res[i] = -maxHeap->data[i];\n    }\n    return res;\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // \u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\u5e76\u5b58\u5165 res \u6570\u7ec4\n    int *res = (int *)malloc(maxHeap->size * sizeof(int));\n    for (int i = 0; i < maxHeap->size; i++) {\n        res[i] = -maxHeap->data[i];\n    }\n    return res;\n}\n\n// \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20\u7684\u51fd\u6570\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (int i = k; i < sizeNums; 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // \u91ca\u653e\u5185\u5b58\n    delMaxHeap(maxHeap);\n    return res;\n}\n
    top_k.kt
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfun topKHeap(nums: IntArray, k: Int): Queue<Int> {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    val heap = PriorityQueue<Int>()\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (i in 0..<k) {\n        heap.offer(nums[i])\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (i in k..<nums.size) {\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\n        if (nums[i] > heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n
    top_k.rb
    [class]{}-[func]{top_k_heap}\n
    top_k.zig
    [class]{}-[func]{topKHeap}\n
    Code Visualization

    Full Screen >

    A total of \\(n\\) rounds of heap insertions and deletions are performed, with the maximum heap size being \\(k\\), hence the time complexity is \\(O(n \\log k)\\). This method is very efficient; when \\(k\\) is small, the time complexity tends towards \\(O(n)\\); when \\(k\\) is large, the time complexity will not exceed \\(O(n \\log n)\\).

    Additionally, this method is suitable for scenarios with dynamic data streams. By continuously adding data, we can maintain the elements within the heap, thereby achieving dynamic updates of the largest \\(k\\) elements.

    "},{"location":"chapter_introduction/","title":"Chapter 1. \u00a0 Introduction to Algorithms","text":"

    Abstract

    A graceful maiden dances, intertwined with the data, her skirt swaying to the melody of algorithms.

    She invites you to a dance, follow her steps, and enter the world of algorithms full of logic and beauty.

    "},{"location":"chapter_introduction/#chapter-contents","title":"Chapter Contents","text":"
    • 1.1 \u00a0 Algorithms are Everywhere
    • 1.2 \u00a0 What is an Algorithm
    • 1.3 \u00a0 Summary
    "},{"location":"chapter_introduction/algorithms_are_everywhere/","title":"1.1 \u00a0 Algorithms are Everywhere","text":"

    When we hear the word \"algorithm,\" we naturally think of mathematics. However, many algorithms do not involve complex mathematics but rely more on basic logic, which can be seen everywhere in our daily lives.

    Before formally discussing algorithms, there's an interesting fact worth sharing: you have already unconsciously learned many algorithms and have become accustomed to applying them in your daily life. Here, I will give a few specific examples to prove this point.

    Example 1: Looking Up a Dictionary. In an English dictionary, words are listed alphabetically. Suppose we're searching for a word that starts with the letter \\(r\\). This is typically done in the following way:

    1. Open the dictionary to about halfway and check the first letter on the page, let's say the letter is \\(m\\).
    2. Since \\(r\\) comes after \\(m\\) in the alphabet, we can ignore the first half of the dictionary and focus on the latter half.
    3. Repeat steps 1. and 2. until you find the page where the word starts with \\(r\\).
    <1><2><3><4><5>

    Figure 1-1 \u00a0 Process of Looking Up a Dictionary

    This essential skill for elementary students, looking up a dictionary, is actually the famous \"Binary Search\" algorithm. From a data structure perspective, we can consider the dictionary as a sorted \"array\"; from an algorithmic perspective, the series of actions taken to look up a word in the dictionary can be viewed as \"Binary Search.\"

    Example 2: Organizing Playing Cards. When playing cards, we need to arrange the cards in our hand in ascending order, as shown in the following process.

    1. Divide the playing cards into \"ordered\" and \"unordered\" sections, assuming initially the leftmost card is already in order.
    2. Take out a card from the unordered section and insert it into the correct position in the ordered section; after this, the leftmost two cards are in order.
    3. Continue to repeat step 2. until all cards are in order.

    Figure 1-2 \u00a0 Playing Cards Sorting Process

    The above method of organizing playing cards is essentially the \"Insertion Sort\" algorithm, which is very efficient for small datasets. Many programming languages' sorting functions include the insertion sort.

    Example 3: Making Change. Suppose we buy goods worth \\(69\\) yuan at a supermarket and give the cashier \\(100\\) yuan, then the cashier needs to give us \\(31\\) yuan in change. They would naturally complete the thought process as shown below.

    1. The options are currencies smaller than \\(31\\), including \\(1\\), \\(5\\), \\(10\\), and \\(20\\).
    2. Take out the largest \\(20\\) from the options, leaving \\(31 - 20 = 11\\).
    3. Take out the largest \\(10\\) from the remaining options, leaving \\(11 - 10 = 1\\).
    4. Take out the largest \\(1\\) from the remaining options, leaving \\(1 - 1 = 0\\).
    5. Complete the change-making, with the solution being \\(20 + 10 + 1 = 31\\).

    Figure 1-3 \u00a0 Change making process

    In the above steps, we make the best choice at each step (using the largest denomination possible), ultimately resulting in a feasible change-making plan. From the perspective of data structures and algorithms, this method is essentially a \"Greedy\" algorithm.

    From cooking a meal to interstellar travel, almost all problem-solving involves algorithms. The advent of computers allows us to store data structures in memory and write code to call the CPU and GPU to execute algorithms. In this way, we can transfer real-life problems to computers, solving various complex issues more efficiently.

    Tip

    If concepts such as data structures, algorithms, arrays, and binary search still seem somewhat obsecure, I encourage you to continue reading. This book will gently guide you into the realm of understanding data structures and algorithms.

    "},{"location":"chapter_introduction/summary/","title":"1.3 \u00a0 Summary","text":"
    • Algorithms are ubiquitous in daily life and are not as inaccessible and complex as they might seem. In fact, we have already unconsciously learned many algorithms to solve various problems in life.
    • The principle of looking up a word in a dictionary is consistent with the binary search algorithm. The binary search algorithm embodies the important algorithmic concept of divide and conquer.
    • The process of organizing playing cards is very similar to the insertion sort algorithm. The insertion sort algorithm is suitable for sorting small datasets.
    • The steps of making change in currency essentially follow the greedy algorithm, where each step involves making the best possible choice at the moment.
    • An algorithm is a set of instructions or steps used to solve a specific problem within a finite amount of time, while a data structure is the way data is organized and stored in a computer.
    • Data structures and algorithms are closely linked. Data structures are the foundation of algorithms, and algorithms are the stage to utilize the functions of data structures.
    • We can liken data structures and algorithms to building blocks. The blocks represent data, the shape and connection method of the blocks represent data structures, and the steps of assembling the blocks correspond to algorithms.
    "},{"location":"chapter_introduction/what_is_dsa/","title":"1.2 \u00a0 What is an Algorithm","text":""},{"location":"chapter_introduction/what_is_dsa/#121-definition-of-an-algorithm","title":"1.2.1 \u00a0 Definition of an Algorithm","text":"

    An \"algorithm\" is a set of instructions or steps to solve a specific problem within a finite amount of time. It has the following characteristics:

    • The problem is clearly defined, including unambiguous definitions of input and output.
    • The algorithm is feasible, meaning it can be completed within a finite number of steps, time, and memory space.
    • Each step has a definitive meaning. The output is consistently the same under the same inputs and conditions.
    "},{"location":"chapter_introduction/what_is_dsa/#122-definition-of-a-data-structure","title":"1.2.2 \u00a0 Definition of a Data Structure","text":"

    A \"data structure\" is a way of organizing and storing data in a computer, with the following design goals:

    • Minimize space occupancy to save computer memory.
    • Make data operations as fast as possible, covering data access, addition, deletion, updating, etc.
    • Provide concise data representation and logical information to enable efficient algorithm execution.

    Designing data structures is a balancing act, often requiring trade-offs. If you want to improve in one aspect, you often need to compromise in another. Here are two examples:

    • Compared to arrays, linked lists offer more convenience in data addition and deletion but sacrifice data access speed.
    • Graphs, compared to linked lists, provide richer logical information but require more memory space.
    "},{"location":"chapter_introduction/what_is_dsa/#123-relationship-between-data-structures-and-algorithms","title":"1.2.3 \u00a0 Relationship Between Data Structures and Algorithms","text":"

    As shown in the Figure 1-4 , data structures and algorithms are highly related and closely integrated, specifically in the following three aspects:

    • Data structures are the foundation of algorithms. They provide structured data storage and methods for manipulating data for algorithms.
    • Algorithms are the stage where data structures come into play. The data structure alone only stores data information; it is through the application of algorithms that specific problems can be solved.
    • Algorithms can often be implemented based on different data structures, but their execution efficiency can vary greatly. Choosing the right data structure is key.

    Figure 1-4 \u00a0 Relationship between data structures and algorithms

    Data structures and algorithms can be likened to a set of building blocks, as illustrated in the Figure 1-5 . A building block set includes numerous pieces, accompanied by detailed assembly instructions. Following these instructions step by step allows us to construct an intricate block model.

    Figure 1-5 \u00a0 Assembling blocks

    The detailed correspondence between the two is shown in the Table 1-1 .

    Table 1-1 \u00a0 Comparing Data Structures and Algorithms to Building Blocks

    Data Structures and Algorithms Building Blocks Input data Unassembled blocks Data structure Organization of blocks, including shape, size, connections, etc Algorithm A series of steps to assemble the blocks into the desired shape Output data Completed Block model

    It's worth noting that data structures and algorithms are independent of programming languages. For this reason, this book is able to provide implementations in multiple programming languages.

    Conventional Abbreviation

    In real-life discussions, we often refer to \"Data Structures and Algorithms\" simply as \"Algorithms\". For example, the well-known LeetCode algorithm problems actually test both data structure and algorithm knowledge.

    "},{"location":"chapter_preface/","title":"Chapter 0. \u00a0 Preface","text":"

    Abstract

    Algorithms are like a beautiful symphony, with each line of code flowing like a rhythm.

    May this book ring softly in your mind, leaving a unique and profound melody.

    "},{"location":"chapter_preface/#chapter-contents","title":"Chapter Contents","text":"
    • 0.1 \u00a0 About This Book
    • 0.2 \u00a0 How to Read
    • 0.3 \u00a0 Summary
    "},{"location":"chapter_preface/about_the_book/","title":"0.1 \u00a0 About This Book","text":"

    This open-source project aims to create a free, and beginner-friendly crash course on data structures and algorithms.

    • Using animated illustrations, it delivers structured insights into data structures and algorithmic concepts, ensuring comprehensibility and a smooth learning curve.
    • Run code with just one click, supporting Java, C++, Python, Go, JS, TS, C#, Swift, Rust, Dart, Zig and other languages.
    • Readers are encouraged to engage with each other in the discussion area for each section, questions and comments are usually answered within two days.
    "},{"location":"chapter_preface/about_the_book/#011-target-audience","title":"0.1.1 \u00a0 Target Audience","text":"

    If you are new to algorithms with limited exposure, or you have accumulated some experience in algorithms, but you only have a vague understanding of data structures and algorithms, and you are constantly jumping between \"yep\" and \"hmm\", then this book is for you!

    If you have already accumulated a certain amount of problem-solving experience, and are familiar with most types of problems, then this book can help you review and organize your algorithm knowledge system. The repository's source code can be used as a \"problem-solving toolkit\" or an \"algorithm cheat sheet\".

    If you are an algorithm expert, we look forward to receiving your valuable suggestions, or join us and collaborate.

    Prerequisites

    You should know how to write and read simple code in at least one programming language.

    "},{"location":"chapter_preface/about_the_book/#012-content-structure","title":"0.1.2 \u00a0 Content Structure","text":"

    The main content of the book is shown in the following figure.

    • Complexity Analysis: explores aspects and methods for evaluating data structures and algorithms. Covers methods of deriving time complexity and space complexity, along with common types and examples.
    • Data Structures: focuses on fundamental data types, classification methods, definitions, pros and cons, common operations, types, applications, and implementation methods of data structures such as array, linked list, stack, queue, hash table, tree, heap, graph, etc.
    • Algorithms: defines algorithms, discusses their pros and cons, efficiency, application scenarios, problem-solving steps, and includes sample questions for various algorithms such as search, sorting, divide and conquer, backtracking, dynamic programming, greedy algorithms, and more.

    Figure 0-1 \u00a0 Main Content of the Book

    "},{"location":"chapter_preface/about_the_book/#013-acknowledgements","title":"0.1.3 \u00a0 Acknowledgements","text":"

    This book is continuously improved with the joint efforts of many contributors from the open-source community. Thanks to each writer who invested their time and energy, listed in the order generated by GitHub: krahets, codingonion, nuomi1, Gonglja, Reanon, justin-tse, danielsss, hpstory, S-N-O-R-L-A-X, night-cruise, msk397, gvenusleo, RiverTwilight, gyt95, zhuoqinyue, Zuoxun, Xia-Sang, mingXta, FangYuan33, GN-Yu, IsChristina, xBLACKICEx, guowei-gong, Cathay-Chen, mgisr, JoseHung, qualifier1024, pengchzn, Guanngxu, longsizhuo, L-Super, what-is-me, yuan0221, lhxsm, Slone123c, WSL0809, longranger2, theNefelibatas, xiongsp, JeffersonHuang, hongyun-robot, K3v123, yuelinxin, a16su, gaofer, malone6, Wonderdch, xjr7670, DullSword, Horbin-Magician, NI-SW, reeswell, XC-Zero, XiaChuerwu, yd-j, iron-irax, huawuque404, MolDuM, Nigh, KorsChen, foursevenlove, 52coder, bubble9um, youshaoXG, curly210102, gltianwen, fanchenggang, Transmigration-zhou, FloranceYeh, FreddieLi, ShiMaRing, lipusheng, Javesun99, JackYang-hellobobo, shanghai-Jerry, 0130w, Keynman, psychelzh, logan-qiu, ZnYang2018, MwumLi, 1ch0, Phoenix0415, qingpeng9802, Richard-Zhang1019, QiLOL, Suremotoo, Turing-1024-Lee, Evilrabbit520, GaochaoZhu, ZJKung, linzeyan, hezhizhen, ZongYangL, beintentional, czruby, coderlef, dshlstarr, szu17dmy, fbigm, gledfish, hts0000, boloboloda, iStig, jiaxianhua, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, liuxjerry, lucaswangdev, lyl625760, chadyi, noobcodemaker, selear, siqyka, syd168, 4yDX3906, tao363, wangwang105, weibk, yabo083, yi427, yishangzhang, zhouLion, baagod, ElaBosak233, xb534, luluxia, yanedie, thomasq0, YangXuanyi and th1nk3r-ing.

    The code review work for this book was completed by codingonion, Gonglja, gvenusleo, hpstory, justin\u2010tse, krahets, night-cruise, nuomi1, and Reanon (listed in alphabetical order). Thanks to them for their time and effort, ensuring the standardization and uniformity of the code in various languages.

    Throughout the creation of this book, numerous individuals provided invaluable assistance, including but not limited to:

    • Thanks to my mentor at the company, Dr. Xi Li, who encouraged me in a conversation to \"get moving fast,\" which solidified my determination to write this book;
    • Thanks to my girlfriend Bubble, as the first reader of this book, for offering many valuable suggestions from the perspective of a beginner in algorithms, making this book more suitable for newbies;
    • Thanks to Tengbao, Qibao, and Feibao for coming up with a creative name for this book, evoking everyone's fond memories of writing their first line of code \"Hello World!\";
    • Thanks to Xiaoquan for providing professional help in intellectual property, which has played a significant role in the development of this open-source book;
    • Thanks to Sutong for designing a beautiful cover and logo for this book, and for patiently making multiple revisions under my insistence;
    • Thanks to @squidfunk for providing writing and typesetting suggestions, as well as his developed open-source documentation theme Material-for-MkDocs.

    Throughout the writing journey, I delved into numerous textbooks and articles on data structures and algorithms. These works served as exemplary models, ensuring the accuracy and quality of this book's content. I extend my gratitude to all who preceded me for their invaluable contributions!

    This book advocates a combination of hands-on and minds-on learning, inspired in this regard by \"Dive into Deep Learning\". I highly recommend this excellent book to all readers.

    Heartfelt thanks to my parents, whose ongoing support and encouragement have allowed me to do this interesting work.

    "},{"location":"chapter_preface/suggestions/","title":"0.2 \u00a0 How to Read","text":"

    Tip

    For the best reading experience, it is recommended that you read through this section.

    "},{"location":"chapter_preface/suggestions/#021-writing-conventions","title":"0.2.1 \u00a0 Writing Conventions","text":"
    • Chapters marked with '*' after the title are optional and contain relatively challenging content. If you are short on time, it is advisable to skip them.
    • Key technical terms and their English equivalents are enclosed in Bold + italics brackets, for example, array. It's advisable to familiarize yourself with these for better comprehension of technical texts.
    • Proprietary terms and words with specific meanings are indicated with \u201cquotation marks\u201d to avoid ambiguity.
    • Bolded text indicates key content or summary statements, which deserve special attention.
    • When it comes to terms that are inconsistent between programming languages, this book follows Python, for example using \\(\\text{None}\\) to mean \"null\".
    • This book partially ignores the comment conventions for programming languages in exchange for a more compact layout of the content. The comments primarily consist of three types: title comments, content comments, and multi-line comments.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig 
    \"\"\"Header comments for labeling functions, classes, test samples, etc\"\"\"\"\n\n# Comments for explaining details\n\n\"\"\"\nMultiline\ncomments\n\"\"\"\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    /* Header comments for labeling functions, classes, test samples, etc */\n\n// Comments for explaining details.\n\n/**\n * Multiline\n * comments\n */\n
    // Header comments for labeling functions, classes, test samples, etc\n\n// Comments for explaining details.\n\n// Multiline\n// comments\n
    "},{"location":"chapter_preface/suggestions/#022-efficient-learning-via-animated-illustrations","title":"0.2.2 \u00a0 Efficient Learning via Animated Illustrations","text":"

    Compared with text, videos and pictures have a higher density of information and are more structured, making them easier to understand. In this book, key and difficult concepts are mainly presented through animations and illustrations, with text serving as explanations and supplements.

    When encountering content with animations or illustrations as shown in the Figure 0-2 , prioritize understanding the figure, with text as supplementary, integrating both for a comprehensive understanding.

    Figure 0-2 \u00a0 Animated Illustration Example

    "},{"location":"chapter_preface/suggestions/#023-deepen-understanding-through-coding-practice","title":"0.2.3 \u00a0 Deepen Understanding through Coding Practice","text":"

    The source code of this book is hosted on the GitHub Repository. As shown in the Figure 0-3 , the source code comes with test examples and can be executed with just a single click.

    If time permits, it's recommended to type out the code yourself. If pressed for time, at least read and run all the codes.

    Compared to just reading code, writing code often yields more learning. Learning by doing is the real way to learn.

    Figure 0-3 \u00a0 Running Code Example

    Setting up to run the code involves three main steps.

    Step 1: Install a local programming environment. Follow the tutorial in the appendix for installation, or skip this step if already installed.

    Step 2: Clone or download the code repository. Visit the GitHub Repository.

    If Git is installed, use the following command to clone the repository:

    git clone https://github.com/krahets/hello-algo.git\n

    Alternatively, you can also click the \"Download ZIP\" button at the location shown in the Figure 0-4 to directly download the code as a compressed ZIP file. Then, you can simply extract it locally.

    Figure 0-4 \u00a0 Cloning Repository and Downloading Code

    Step 3: Run the source code. As shown in the Figure 0-5 , for the code block labeled with the file name at the top, we can find the corresponding source code file in the codes folder of the repository. These files can be executed with a single click, which will help you save unnecessary debugging time and allow you to focus on learning.

    Figure 0-5 \u00a0 Code Block and Corresponding Source Code File

    "},{"location":"chapter_preface/suggestions/#024-learning-together-in-discussion","title":"0.2.4 \u00a0 Learning Together in Discussion","text":"

    While reading this book, please don't skip over the points that you didn't learn. Feel free to post your questions in the comment section. We will be happy to answer them and can usually respond within two days.

    As illustrated in the Figure 0-6 , each chapter features a comment section at the bottom. I encourage you to pay attention to these comments. They not only expose you to others' encountered problems, aiding in identifying knowledge gaps and sparking deeper contemplation, but also invite you to generously contribute by answering fellow readers' inquiries, sharing insights, and fostering mutual improvement.

    Figure 0-6 \u00a0 Comment Section Example

    "},{"location":"chapter_preface/suggestions/#025-algorithm-learning-path","title":"0.2.5 \u00a0 Algorithm Learning Path","text":"

    Overall, the journey of mastering data structures and algorithms can be divided into three stages:

    1. Stage 1: Introduction to algorithms. We need to familiarize ourselves with the characteristics and usage of various data structures and learn about the principles, processes, uses, and efficiency of different algorithms.
    2. Stage 2: Practicing algorithm problems. It is recommended to start from popular problems, such as Sword for Offer and LeetCode Hot 100, and accumulate at least 100 questions to familiarize yourself with mainstream algorithmic problems. Forgetfulness can be a challenge when you start practicing, but rest assured that this is normal. We can follow the \"Ebbinghaus Forgetting Curve\" to review the questions, and usually after 3~5 rounds of repetitions, we will be able to memorize them.
    3. Stage 3: Building the knowledge system. In terms of learning, we can read algorithm column articles, solution frameworks, and algorithm textbooks to continuously enrich the knowledge system. In terms of practicing, we can try advanced strategies, such as categorizing by topic, multiple solutions for a single problem, and one solution for multiple problems, etc. Insights on these strategies can be found in various communities.

    As shown in the Figure 0-7 , this book mainly covers \u201cStage 1,\u201d aiming to help you more efficiently embark on Stages 2 and 3.

    Figure 0-7 \u00a0 Algorithm Learning Path

    "},{"location":"chapter_preface/summary/","title":"0.3 \u00a0 Summary","text":"
    • The main audience of this book is beginners in algorithm. If you already have some basic knowledge, this book can help you systematically review your algorithm knowledge, and the source code in this book can also be used as a \"Coding Toolkit\".
    • The book consists of three main sections, Complexity Analysis, Data Structures, and Algorithms, covering most of the topics in the field.
    • For newcomers to algorithms, it is crucial to read an introductory book in the beginning stages to avoid many detours or common pitfalls.
    • Animations and figures within the book are usually used to introduce key points and difficult knowledge. These should be given more attention when reading the book.
    • Practice is the best way to learn programming. It is highly recommended that you run the source code and type in the code yourself.
    • Each chapter in the web version of this book features a discussion section, and you are welcome to share your questions and insights at any time.
    "},{"location":"chapter_stack_and_queue/","title":"Chapter 5. \u00a0 Stack and Queue","text":"

    Abstract

    A stack is like cats placed on top of each other, while a queue is like cats lined up one by one.

    They represent the logical relationships of Last-In-First-Out (LIFO) and First-In-First-Out (FIFO), respectively.

    "},{"location":"chapter_stack_and_queue/#chapter-contents","title":"Chapter Contents","text":"
    • 5.1 \u00a0 Stack
    • 5.2 \u00a0 Queue
    • 5.3 \u00a0 Double-ended Queue
    • 5.4 \u00a0 Summary
    "},{"location":"chapter_stack_and_queue/deque/","title":"5.3 \u00a0 Double-Ended Queue","text":"

    In a queue, we can only delete elements from the head or add elements to the tail. As shown in the following diagram, a \"double-ended queue (deque)\" offers more flexibility, allowing the addition or removal of elements at both the head and the tail.

    Figure 5-7 \u00a0 Operations in Double-Ended Queue

    "},{"location":"chapter_stack_and_queue/deque/#531-common-operations-in-double-ended-queue","title":"5.3.1 \u00a0 Common Operations in Double-Ended Queue","text":"

    The common operations in a double-ended queue are listed below, and the names of specific methods depend on the programming language used.

    Table 5-3 \u00a0 Efficiency of Double-Ended Queue Operations

    Method Name Description Time Complexity pushFirst() Add an element to the head \\(O(1)\\) pushLast() Add an element to the tail \\(O(1)\\) popFirst() Remove the first element \\(O(1)\\) popLast() Remove the last element \\(O(1)\\) peekFirst() Access the first element \\(O(1)\\) peekLast() Access the last element \\(O(1)\\)

    Similarly, we can directly use the double-ended queue classes implemented in programming languages:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig deque.py
    from collections import deque\n\n# Initialize the deque\ndeque: deque[int] = deque()\n\n# Enqueue elements\ndeque.append(2)      # Add to the tail\ndeque.append(5)\ndeque.append(4)\ndeque.appendleft(3)  # Add to the head\ndeque.appendleft(1)\n\n# Access elements\nfront: int = deque[0]  # The first element\nrear: int = deque[-1]  # The last element\n\n# Dequeue elements\npop_front: int = deque.popleft()  # The first element dequeued\npop_rear: int = deque.pop()       # The last element dequeued\n\n# Get the length of the deque\nsize: int = len(deque)\n\n# Check if the deque is empty\nis_empty: bool = len(deque) == 0\n
    deque.cpp
    /* Initialize the deque */\ndeque<int> deque;\n\n/* Enqueue elements */\ndeque.push_back(2);   // Add to the tail\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3);  // Add to the head\ndeque.push_front(1);\n\n/* Access elements */\nint front = deque.front(); // The first element\nint back = deque.back();   // The last element\n\n/* Dequeue elements */\ndeque.pop_front();  // The first element dequeued\ndeque.pop_back();   // The last element dequeued\n\n/* Get the length of the deque */\nint size = deque.size();\n\n/* Check if the deque is empty */\nbool empty = deque.empty();\n
    deque.java
    /* Initialize the deque */\nDeque<Integer> deque = new LinkedList<>();\n\n/* Enqueue elements */\ndeque.offerLast(2);   // Add to the tail\ndeque.offerLast(5);\ndeque.offerLast(4);\ndeque.offerFirst(3);  // Add to the head\ndeque.offerFirst(1);\n\n/* Access elements */\nint peekFirst = deque.peekFirst();  // The first element\nint peekLast = deque.peekLast();    // The last element\n\n/* Dequeue elements */\nint popFirst = deque.pollFirst();  // The first element dequeued\nint popLast = deque.pollLast();    // The last element dequeued\n\n/* Get the length of the deque */\nint size = deque.size();\n\n/* Check if the deque is empty */\nboolean isEmpty = deque.isEmpty();\n
    deque.cs
    /* Initialize the deque */\n// In C#, LinkedList is used as a deque\nLinkedList<int> deque = new();\n\n/* Enqueue elements */\ndeque.AddLast(2);   // Add to the tail\ndeque.AddLast(5);\ndeque.AddLast(4);\ndeque.AddFirst(3);  // Add to the head\ndeque.AddFirst(1);\n\n/* Access elements */\nint peekFirst = deque.First.Value;  // The first element\nint peekLast = deque.Last.Value;    // The last element\n\n/* Dequeue elements */\ndeque.RemoveFirst();  // The first element dequeued\ndeque.RemoveLast();   // The last element dequeued\n\n/* Get the length of the deque */\nint size = deque.Count;\n\n/* Check if the deque is empty */\nbool isEmpty = deque.Count == 0;\n
    deque_test.go
    /* Initialize the deque */\n// In Go, use list as a deque\ndeque := list.New()\n\n/* Enqueue elements */\ndeque.PushBack(2)      // Add to the tail\ndeque.PushBack(5)\ndeque.PushBack(4)\ndeque.PushFront(3)     // Add to the head\ndeque.PushFront(1)\n\n/* Access elements */\nfront := deque.Front() // The first element\nrear := deque.Back()   // The last element\n\n/* Dequeue elements */\ndeque.Remove(front)    // The first element dequeued\ndeque.Remove(rear)     // The last element dequeued\n\n/* Get the length of the deque */\nsize := deque.Len()\n\n/* Check if the deque is empty */\nisEmpty := deque.Len() == 0\n
    deque.swift
    /* Initialize the deque */\n// Swift does not have a built-in deque class, so Array can be used as a deque\nvar deque: [Int] = []\n\n/* Enqueue elements */\ndeque.append(2) // Add to the tail\ndeque.append(5)\ndeque.append(4)\ndeque.insert(3, at: 0) // Add to the head\ndeque.insert(1, at: 0)\n\n/* Access elements */\nlet peekFirst = deque.first! // The first element\nlet peekLast = deque.last!   // The last element\n\n/* Dequeue elements */\n// Using Array, popFirst has a complexity of O(n)\nlet popFirst = deque.removeFirst() // The first element dequeued\nlet popLast = deque.removeLast()   // The last element dequeued\n\n/* Get the length of the deque */\nlet size = deque.count\n\n/* Check if the deque is empty */\nlet isEmpty = deque.isEmpty\n
    deque.js
    /* Initialize the deque */\n// JavaScript does not have a built-in deque, so Array is used as a deque\nconst deque = [];\n\n/* Enqueue elements */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Note that unshift() has a time complexity of O(n) as it's an array\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Access elements */\nconst peekFirst = deque[0]; // The first element\nconst peekLast = deque[deque.length - 1]; // The last element\n\n/* Dequeue elements */\n// Note that shift() has a time complexity of O(n) as it's an array\nconst popFront = deque.shift(); // The first element dequeued\nconst popBack = deque.pop();    // The last element dequeued\n\n/* Get the length of the deque */\nconst size = deque.length;\n\n/* Check if the deque is empty */\nconst isEmpty = size === 0;\n
    deque.ts
    /* Initialize the deque */\n// TypeScript does not have a built-in deque, so Array is used as a deque\nconst deque: number[] = [];\n\n/* Enqueue elements */\ndeque.push(2);\ndeque.push(5);\ndeque.push(4);\n// Note that unshift() has a time complexity of O(n) as it's an array\ndeque.unshift(3);\ndeque.unshift(1);\n\n/* Access elements */\nconst peekFirst: number = deque[0]; // The first element\nconst peekLast: number = deque[deque.length - 1]; // The last element\n\n/* Dequeue elements */\n// Note that shift() has a time complexity of O(n) as it's an array\nconst popFront: number = deque.shift() as number; // The first element dequeued\nconst popBack: number = deque.pop() as number;    // The last element dequeued\n\n/* Get the length of the deque */\nconst size: number = deque.length;\n\n/* Check if the deque is empty */\nconst isEmpty: boolean = size === 0;\n
    deque.dart
    /* Initialize the deque */\n// In Dart, Queue is defined as a deque\nQueue<int> deque = Queue<int>();\n\n/* Enqueue elements */\ndeque.addLast(2);  // Add to the tail\ndeque.addLast(5);\ndeque.addLast(4);\ndeque.addFirst(3); // Add to the head\ndeque.addFirst(1);\n\n/* Access elements */\nint peekFirst = deque.first; // The first element\nint peekLast = deque.last;   // The last element\n\n/* Dequeue elements */\nint popFirst = deque.removeFirst(); // The first element dequeued\nint popLast = deque.removeLast();   // The last element dequeued\n\n/* Get the length of the deque */\nint size = deque.length;\n\n/* Check if the deque is empty */\nbool isEmpty = deque.isEmpty;\n
    deque.rs
    /* Initialize the deque */\nlet mut deque: VecDeque<u32> = VecDeque::new();\n\n/* Enqueue elements */\ndeque.push_back(2);  // Add to the tail\ndeque.push_back(5);\ndeque.push_back(4);\ndeque.push_front(3); // Add to the head\ndeque.push_front(1);\n\n/* Access elements */\nif let Some(front) = deque.front() { // The first element\n}\nif let Some(rear) = deque.back() {   // The last element\n}\n\n/* Dequeue elements */\nif let Some(pop_front) = deque.pop_front() { // The first element dequeued\n}\nif let Some(pop_rear) = deque.pop_back() {   // The last element dequeued\n}\n\n/* Get the length of the deque */\nlet size = deque.len();\n\n/* Check if the deque is empty */\nlet is_empty = deque.is_empty();\n
    deque.c
    // C does not provide a built-in deque\n
    deque.kt
    \n
    deque.zig
    \n
    Visualizing Code

    https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%0A%20%20%20%20deq%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20deq.append%282%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E5%B0%BE%0A%20%20%20%20deq.append%285%29%0A%20%20%20%20deq.append%284%29%0A%20%20%20%20deq.appendleft%283%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E9%A6%96%0A%20%20%20%20deq.appendleft%281%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20deq%5B0%5D%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%20%20%20%20rear%20%3D%20deq%5B-1%5D%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%20rear%20%3D%22,%20rear%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop_front%20%3D%20deq.popleft%28%29%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_front%20%3D%22,%20pop_front%29%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%20%20%20%20pop_rear%20%3D%20deq.pop%28%29%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_rear%20%3D%22,%20pop_rear%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28deq%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28deq%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false

    "},{"location":"chapter_stack_and_queue/deque/#532-implementing-a-double-ended-queue","title":"5.3.2 \u00a0 Implementing a Double-Ended Queue *","text":"

    The implementation of a double-ended queue is similar to that of a regular queue, it can be based on either a linked list or an array as the underlying data structure.

    "},{"location":"chapter_stack_and_queue/deque/#1-implementation-based-on-doubly-linked-list","title":"1. \u00a0 Implementation Based on Doubly Linked List","text":"

    Recall from the previous section that we used a regular singly linked list to implement a queue, as it conveniently allows for deleting from the head (corresponding to the dequeue operation) and adding new elements after the tail (corresponding to the enqueue operation).

    For a double-ended queue, both the head and the tail can perform enqueue and dequeue operations. In other words, a double-ended queue needs to implement operations in the opposite direction as well. For this, we use a \"doubly linked list\" as the underlying data structure of the double-ended queue.

    As shown in the Figure 5-8 , we treat the head and tail nodes of the doubly linked list as the front and rear of the double-ended queue, respectively, and implement the functionality to add and remove nodes at both ends.

    LinkedListDequepushLast()pushFirst()popLast()popFirst()

    Figure 5-8 \u00a0 Implementing Double-Ended Queue with Doubly Linked List for Enqueue and Dequeue Operations

    The implementation code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_deque.py
    class ListNode:\n    \"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n        self.prev: ListNode | None = None  # \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\nclass LinkedListDeque:\n    \"\"\"\u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._front: ListNode | None = None  # \u5934\u8282\u70b9 front\n        self._rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\n        self._size: int = 0  # \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self.size() == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"\u5165\u961f\u64cd\u4f5c\"\"\"\n        node = ListNode(num)\n        # \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if self.is_empty():\n            self._front = self._rear = node\n        # \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        elif is_front:\n            # \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            self._front.prev = node\n            node.next = self._front\n            self._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\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # \u66f4\u65b0\u5c3e\u8282\u70b9\n        self._size += 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n\n    def push_first(self, num: int):\n        \"\"\"\u961f\u9996\u5165\u961f\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -> int:\n        \"\"\"\u51fa\u961f\u64cd\u4f5c\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        # \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if is_front:\n            val: int = self._front.val  # \u6682\u5b58\u5934\u8282\u70b9\u503c\n            # \u5220\u9664\u5934\u8282\u70b9\n            fnext: ListNode | None = self._front.next\n            if fnext != None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # \u66f4\u65b0\u5934\u8282\u70b9\n        # \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else:\n            val: int = self._rear.val  # \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            # \u5220\u9664\u5c3e\u8282\u70b9\n            rprev: ListNode | None = self._rear.prev\n            if rprev != None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # \u66f4\u65b0\u5c3e\u8282\u70b9\n        self._size -= 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val\n\n    def pop_first(self) -> int:\n        \"\"\"\u961f\u9996\u51fa\u961f\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -> int:\n        \"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._front.val\n\n    def peek_last(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._rear.val\n\n    def to_array(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n
    linkedlist_deque.cpp
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nstruct DoublyListNode {\n    int val;              // \u8282\u70b9\u503c\n    DoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n    DoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\u6307\u9488\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize = 0;              // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~LinkedListDeque() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur->next;\n            delete pre;\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty())\n            front = rear = node;\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front->prev = node;\n            node->next = front;\n            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\n            rear->next = node;\n            node->prev = rear;\n            rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        int val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front->val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            DoublyListNode *fNext = front->next;\n            if (fNext != nullptr) {\n                fNext->prev = nullptr;\n                front->next = nullptr;\n            }\n            delete front;\n            front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            val = rear->val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            DoublyListNode *rPrev = rear->prev;\n            if (rPrev != nullptr) {\n                rPrev->next = nullptr;\n                rear->prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return front->val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return rear->val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        DoublyListNode *node = front;\n        vector<int> res(size());\n        for (int i = 0; i < res.size(); i++) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_deque.java
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    int val; // \u8282\u70b9\u503c\n    ListNode next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    ListNode prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private int queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty())\n            front = rear = node;\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front.prev = node;\n            node.next = front;\n            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\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            val = rear.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_deque.cs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode(int val) {\n    public int val = val;       // \u8282\u70b9\u503c\n    public ListNode? next = null; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    public ListNode? prev = null; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    ListNode? front, rear; // \u5934\u8282\u70b9 front, \u5c3e\u8282\u70b9 rear\n    int queSize = 0;      // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front!.prev = node;\n            node.next = front;\n            front = node; // \u66f4\u65b0\u5934\u8282\u70b9                           \n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front?.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            val = rear?.val;  // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i < res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u53cc\u7aef\u961f\u5217 */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* \u961f\u9996\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* \u961f\u5c3e\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* \u961f\u9996\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u961f\u5c3e\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n
    linkedlist_deque.swift
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    var val: Int // \u8282\u70b9\u503c\n    var next: ListNode? // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    weak var prev: ListNode? // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private var front: ListNode? // \u5934\u8282\u70b9 front\n    private var rear: ListNode? // \u5c3e\u8282\u70b9 rear\n    private var _size: Int // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if isFront {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front?.prev = node\n            node.next = front\n            front = node // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            rear?.next = node\n            node.prev = rear\n            rear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        _size += 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    private func pop(isFront: Bool) -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        let val: Int\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if isFront {\n            val = front!.val // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            val = rear!.val // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        _size -= 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    func popFirst() -> Int {\n        pop(isFront: true)\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    func popLast() -> Int {\n        pop(isFront: false)\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peekFirst() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return front!.val\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    func peekLast() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return rear!.val\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    func toArray() -> [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n
    linkedlist_deque.js
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    val; // \u8282\u70b9\u503c\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\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\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        this.#queSize++;\n    }\n\n    /* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        this.#queSize++;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5c3e\u8282\u70b9\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        this.#queSize--;\n        return value;\n    }\n\n    /* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5934\u8282\u70b9\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\n        this.#queSize--;\n        return value;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u6253\u5370\u53cc\u5411\u961f\u5217 */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n
    linkedlist_deque.ts
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    prev: ListNode; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    next: ListNode; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    val: number; // \u8282\u70b9\u503c\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private front: ListNode; // \u5934\u8282\u70b9 front\n    private rear: ListNode; // \u5c3e\u8282\u70b9 rear\n    private queSize: number; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        this.queSize++;\n    }\n\n    /* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        this.queSize++;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5c3e\u8282\u70b9\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        this.queSize--;\n        return value;\n    }\n\n    /* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5934\u8282\u70b9\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\n        this.queSize--;\n        return value;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u6253\u5370\u53cc\u5411\u961f\u5217 */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n
    linkedlist_deque.dart
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n  int val; // \u8282\u70b9\u503c\n  ListNode? next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n  ListNode? prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u5bf9\u5217 */\nclass LinkedListDeque {\n  late ListNode? _front; // \u5934\u8282\u70b9 _front\n  late ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\n  int _queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u957f\u5ea6 */\n  int size() {\n    return this._queSize;\n  }\n\n  /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* \u5165\u961f\u64cd\u4f5c */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 _front \u548c _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;\n      node.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;\n      node.prev = _rear;\n      _rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    _queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n  }\n\n  /* \u961f\u9996\u5165\u961f */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* \u961f\u5c3e\u5165\u961f */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* \u51fa\u961f\u64cd\u4f5c */\n  int? pop(bool isFront) {\n    // \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n      val = _front!.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n      // \u5220\u9664\u5934\u8282\u70b9\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n    } else {\n      // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n      val = _rear!.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n      // \u5220\u9664\u5c3e\u8282\u70b9\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    _queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    return val;\n  }\n\n  /* \u961f\u9996\u51fa\u961f */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* \u961f\u5c3e\u51fa\u961f */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n  List<int> toArray() {\n    ListNode? node = _front;\n    final List<int> res = [];\n    for (int i = 0; i < _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n
    linkedlist_deque.rs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\npub struct ListNode<T> {\n    pub val: T,                                 // \u8282\u70b9\u503c\n    pub next: Option<Rc<RefCell<ListNode<T>>>>, // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n    pub prev: Option<Rc<RefCell<ListNode<T>>>>, // \u524d\u9a71\u8282\u70b9\u6307\u9488\n}\n\nimpl<T> ListNode<T> {\n    pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\n#[allow(dead_code)]\npub struct LinkedListDeque<T> {\n    front: Option<Rc<RefCell<ListNode<T>>>>, // \u5934\u8282\u70b9 front\n    rear: Option<Rc<RefCell<ListNode<T>>>>,  // \u5c3e\u8282\u70b9 rear\n    que_size: usize,                         // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListDeque<T> {\n    pub fn new() -> Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.que_size;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    pub fn push(&mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        if is_front {\n            match self.front.take() {\n                // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n                None => {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n                Some(old_front) => {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // \u66f4\u65b0\u5934\u8282\u70b9\n                }\n            }\n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            match self.rear.take() {\n                // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n                None => {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n                Some(old_rear) => {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // \u66f4\u65b0\u5c3e\u8282\u70b9\n                }\n            }\n        }\n        self.que_size += 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pub fn push_first(&mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pub fn push_last(&mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    pub fn pop(&mut self, is_front: bool) -> Option<T> {\n        // \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de None\n        if self.is_empty() {\n            return None;\n        };\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) => {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // \u66f4\u65b0\u5934\u8282\u70b9\n                    }\n                    None => {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n                Rc::try_unwrap(old_front).ok().unwrap().into_inner().val\n            })\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) => {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // \u66f4\u65b0\u5c3e\u8282\u70b9\n                    }\n                    None => {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n                Rc::try_unwrap(old_rear).ok().unwrap().into_inner().val\n            })\n        }\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    pub fn pop_first(&mut self) -> Option<T> {\n        return self.pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    pub fn pop_last(&mut self) -> Option<T> {\n        return self.pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    pub fn peek_first(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.front.as_ref()\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    pub fn peek_last(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.rear.as_ref()\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.insert(0, node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_deque.c
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\ntypedef struct DoublyListNode {\n    int val;                     // \u8282\u70b9\u503c\n    struct DoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\n    struct DoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\n} DoublyListNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new->val = num;\n    new->next = NULL;\n    new->prev = NULL;\n    return new;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntypedef struct {\n    DoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize;                  // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n} LinkedListDeque;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque->front = NULL;\n    deque->rear = NULL;\n    deque->queSize = 0;\n    return deque;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // \u91ca\u653e\u6240\u6709\u8282\u70b9\n    for (int i = 0; i < deque->queSize && deque->front != NULL; i++) {\n        DoublyListNode *tmp = deque->front;\n        deque->front = deque->front->next;\n        free(tmp);\n    }\n    // \u91ca\u653e deque \u7ed3\u6784\u4f53\n    free(deque);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(LinkedListDeque *deque) {\n    return deque->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* \u5165\u961f */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411node\n    if (empty(deque)) {\n        deque->front = deque->rear = node;\n    }\n    // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n    else if (isFront) {\n        // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n        deque->front->prev = node;\n        node->next = deque->front;\n        deque->front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n    }\n    // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n    else {\n        // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n        deque->rear->next = node;\n        node->prev = deque->rear;\n        deque->rear = node;\n    }\n    deque->queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) && deque->front);\n    return deque->front->val;\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) && deque->rear);\n    return deque->rear->val;\n}\n\n/* \u51fa\u961f */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n    if (isFront) {\n        val = peekFirst(deque); // \u6682\u5b58\u5934\u8282\u70b9\u503c\n        DoublyListNode *fNext = deque->front->next;\n        if (fNext) {\n            fNext->prev = NULL;\n            deque->front->next = NULL;\n            delDoublyListNode(deque->front);\n        }\n        deque->front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n    }\n    // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n    else {\n        val = peekLast(deque); // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n        DoublyListNode *rPrev = deque->rear->prev;\n        if (rPrev) {\n            rPrev->next = NULL;\n            deque->rear->prev = NULL;\n            delDoublyListNode(deque->rear);\n        }\n        deque->rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    deque->queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    return val;\n}\n\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque->queSize);\n    // \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque->front; i < deque->queSize; i++) {\n        arr[i] = node->val;\n        node = node->next;\n    }\n    printArray(arr, deque->queSize);\n    free(arr);\n}\n
    linkedlist_deque.kt
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode(var value: Int) {\n    // \u8282\u70b9\u503c\n    var next: ListNode? = null // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    var prev: ListNode? = null // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private var front: ListNode? = null // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private var rear: ListNode? = null\n    private var queSize = 0 // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        } else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front?.prev = node\n            node.next = front\n            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\n            rear?.next = node\n            node.prev = rear\n            rear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++ // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n\n        val value: Int\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            value = front!!.value // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n            // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            value = rear!!.value // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize-- // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return value\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peekFirst(): Int {\n        if (isEmpty()) {\n            throw IndexOutOfBoundsException()\n\n        }\n        return front!!.value\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!.value\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!.value\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_deque.rb
    [class]{ListNode}-[func]{}\n\n[class]{LinkedListDeque}-[func]{}\n
    linkedlist_deque.zig
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\nfn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = undefined,     // \u8282\u70b9\u503c\n        next: ?*Self = null,    // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n        prev: ?*Self = null,    // \u524d\u9a71\u8282\u70b9\u6307\u9488\n\n        // Initialize a list node with specific value\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n            self.prev = null;\n        }\n    };\n}\n\n// \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\nfn LinkedListDeque(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        front: ?*ListNode(T) = null,                    // \u5934\u8282\u70b9 front\n        rear: ?*ListNode(T) = null,                     // \u5c3e\u8282\u70b9 rear\n        que_size: usize = 0,                             // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.front = null;\n            self.rear = null;\n            self.que_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.que_size;\n        }\n\n        // \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u5165\u961f\u64cd\u4f5c\n        pub fn push(self: *Self, num: T, is_front: bool) !void {\n            var node = try self.mem_allocator.create(ListNode(T));\n            node.init(num);\n            // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n            if (self.isEmpty()) {\n                self.front = node;\n                self.rear = node;\n            // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n            } else if (is_front) {\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n                self.front.?.prev = node;\n                node.next = self.front;\n                self.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\n                self.rear.?.next = node;\n                node.prev = self.rear;\n                self.rear = node;   // \u66f4\u65b0\u5c3e\u8282\u70b9\n            }\n            self.que_size += 1;      // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        } \n\n        // \u961f\u9996\u5165\u961f\n        pub fn pushFirst(self: *Self, num: T) !void {\n            try self.push(num, true);\n        } \n\n        // \u961f\u5c3e\u5165\u961f\n        pub fn pushLast(self: *Self, num: T) !void {\n            try self.push(num, false);\n        } \n\n        // \u51fa\u961f\u64cd\u4f5c\n        pub fn pop(self: *Self, is_front: bool) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            var val: T = undefined;\n            // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n            if (is_front) {\n                val = self.front.?.val;     // \u6682\u5b58\u5934\u8282\u70b9\u503c\n                // \u5220\u9664\u5934\u8282\u70b9\n                var fNext = self.front.?.next;\n                if (fNext != null) {\n                    fNext.?.prev = null;\n                    self.front.?.next = null;\n                }\n                self.front = fNext;         // \u66f4\u65b0\u5934\u8282\u70b9\n            // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n            } else {\n                val = self.rear.?.val;      // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n                // \u5220\u9664\u5c3e\u8282\u70b9\n                var rPrev = self.rear.?.prev;\n                if (rPrev != null) {\n                    rPrev.?.next = null;\n                    self.rear.?.prev = null;\n                }\n                self.rear = rPrev;          // \u66f4\u65b0\u5c3e\u8282\u70b9\n            }\n            self.que_size -= 1;              // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n            return val;\n        } \n\n        // \u961f\u9996\u51fa\u961f\n        pub fn popFirst(self: *Self) T {\n            return self.pop(true);\n        } \n\n        // \u961f\u5c3e\u51fa\u961f\n        pub fn popLast(self: *Self) T {\n            return self.pop(false);\n        } \n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peekFirst(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            return self.front.?.val;\n        }  \n\n        // \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\n        pub fn peekLast(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            return self.rear.?.val;\n        }\n\n        // \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.front;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[i] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    "},{"location":"chapter_stack_and_queue/deque/#2-implementation-based-on-array","title":"2. \u00a0 Implementation Based on Array","text":"

    As shown in the Figure 5-9 , similar to implementing a queue with an array, we can also use a circular array to implement a double-ended queue.

    ArrayDequepushLast()pushFirst()popLast()popFirst()

    Figure 5-9 \u00a0 Implementing Double-Ended Queue with Array for Enqueue and Dequeue Operations

    The implementation only needs to add methods for \"front enqueue\" and \"rear dequeue\":

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_deque.py
    class ArrayDeque:\n    \"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\n        return len(self._nums)\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._size == 0\n\n    def 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\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"\u961f\u9996\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        # \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        # \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        self._front = self.index(self._front - 1)\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        # \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        rear = self.index(self._front + self._size)\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -> int:\n        \"\"\"\u961f\u9996\u51fa\u961f\"\"\"\n        num = self.peek_first()\n        # \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -> int:\n        \"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._nums[self._front]\n\n    def peek_last(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        # \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def 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\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n
    array_deque.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n  private:\n    vector<int> nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;      // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    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\n        return (i + capacity()) % capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    int popFirst() {\n        int num = peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> res(queSize);\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n
    array_deque.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private int[] nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private 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\n        return (i + capacity()) % capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int popFirst() {\n        int num = peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    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\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = Index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntype arrayDeque struct {\n    nums        []int // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    queSize     int   // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n    queCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\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\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* \u961f\u9996\u5165\u961f */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n        return\n    }\n    // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n    q.front = q.index(q.front - 1)\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n        return\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    rear := q.index(q.front + q.queSize)\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* \u961f\u9996\u51fa\u961f */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    q.queSize--\n    return num\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\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\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i < q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n
    array_deque.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var _size: Int // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    func capacity() -> Int {\n        nums.count\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private 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\n    /* \u961f\u9996\u5165\u961f */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        front = index(i: front - 1)\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        nums[front] = num\n        _size += 1\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        let rear = index(i: front + size())\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    func popFirst() -> Int {\n        let num = peekFirst()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    func popLast() -> Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peekFirst() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return nums[front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    func peekLast() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    func toArray() -> [Int] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        (front ..< front + size()).map { nums[index(i: $0)] }\n    }\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\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    index(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\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        this.#front = this.index(this.#front - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        const rear = this.index(this.#front + this.#queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    popFirst() {\n        const num = this.peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const res = [];\n        for (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private queSize: number; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    index(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\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        this.front = this.index(this.front - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        const rear: number = this.index(this.front + this.queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    toArray(): number[] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i < this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n  late List<int> _nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n  late int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n  late int _queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n  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\n    return (i + capacity()) % capacity();\n  }\n\n  /* \u961f\u9996\u5165\u961f */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw 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\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\n  /* \u961f\u5c3e\u5165\u961f */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    int rear = index(_front + _queSize);\n    // \u5c06 _num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* \u961f\u9996\u51fa\u961f */\n  int popFirst() {\n    int _num = peekFirst();\n    // \u961f\u9996\u6307\u9488\u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* \u961f\u5c3e\u51fa\u961f */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n    }\n    return _nums[_front];\n  }\n\n  /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n    }\n    // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n  List<int> toArray() {\n    // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    List<int> res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i < _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n
    array_deque.rs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nstruct ArrayDeque {\n    nums: Vec<i32>,  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front: usize,    // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    que_size: usize, // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n}\n\nimpl ArrayDeque {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(capacity: usize) -> Self {\n        Self {\n            nums: vec![0; capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    pub fn capacity(&self) -> usize {\n        self.nums.len()\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        self.que_size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        self.que_size == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    fn index(&self, i: i32) -> usize {\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        return ((i + self.capacity() as i32) % self.capacity() as i32) as usize;\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pub fn push_first(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        self.front = self.index(self.front as i32 - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pub fn push_last(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fn pop_first(&mut self) -> i32 {\n        let num = self.peek_first();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    fn pop_last(&mut self) -> i32 {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fn peek_first(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        };\n        self.nums[self.front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fn peek_last(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        };\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fn to_array(&self) -> Vec<i32> {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        let mut res = vec![0; self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n
    array_deque.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntypedef struct {\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n} ArrayDeque;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // \u521d\u59cb\u5316\u6570\u7ec4\n    deque->queCapacity = capacity;\n    deque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);\n    deque->front = deque->queSize = 0;\n    return deque;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque->nums);\n    free(deque);\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(ArrayDeque *deque) {\n    return deque->queCapacity;\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size(ArrayDeque *deque) {\n    return deque->queSize;\n}\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(ArrayDeque *deque) {\n    return deque->queSize == 0;\n}\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\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque->queSize == capacity(deque)) {\n        printf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u56de\u5230\u5c3e\u90e8\n    deque->front = dequeIndex(deque, deque->front - 1);\n    // \u5c06 num \u6dfb\u52a0\u5230\u961f\u9996\n    deque->nums[deque->front] = num;\n    deque->queSize++;\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque->queSize == capacity(deque)) {\n        printf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    int rear = dequeIndex(deque, deque->front + deque->queSize);\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    deque->nums[rear] = num;\n    deque->queSize++;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(ArrayDeque *deque) {\n    // \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\n    assert(empty(deque) == 0);\n    return deque->nums[deque->front];\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(ArrayDeque *deque) {\n    // \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque->front + deque->queSize - 1);\n    return deque->nums[last];\n}\n\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    deque->front = dequeIndex(deque, deque->front + 1);\n    deque->queSize--;\n    return num;\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque->queSize--;\n    return num;\n}\n
    array_deque.kt
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque(capacity: Int) {\n    private var nums = IntArray(capacity) // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var queSize = 0 // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private fun 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        return (i + capacity()) % capacity()\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        val rear = index(front + queSize)\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        queSize++\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fun toArray(): IntArray {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i < queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n
    array_deque.rb
    [class]{ArrayDeque}-[func]{}\n
    array_deque.zig
    [class]{ArrayDeque}-[func]{}\n
    "},{"location":"chapter_stack_and_queue/deque/#533-applications-of-double-ended-queue","title":"5.3.3 \u00a0 Applications of Double-Ended Queue","text":"

    The double-ended queue combines the logic of both stacks and queues, thus, it can implement all their respective use cases while offering greater flexibility.

    We know that software's \"undo\" feature is typically implemented using a stack: the system pushes each change operation onto the stack and then pops to implement undoing. However, considering the limitations of system resources, software often restricts the number of undo steps (for example, only allowing the last 50 steps). When the stack length exceeds 50, the software needs to perform a deletion operation at the bottom of the stack (the front of the queue). But a regular stack cannot perform this function, where a double-ended queue becomes necessary. Note that the core logic of \"undo\" still follows the Last-In-First-Out principle of a stack, but a double-ended queue can more flexibly implement some additional logic.

    "},{"location":"chapter_stack_and_queue/queue/","title":"5.2 \u00a0 Queue","text":"

    \"Queue\" is a linear data structure that follows the First-In-First-Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers join the queue at the rear, and the person at the front leaves the queue first.

    As shown in the Figure 5-4 , we call the front of the queue the \"head\" and the back the \"tail.\" The operation of adding elements to the rear of the queue is termed \"enqueue,\" and the operation of removing elements from the front is termed \"dequeue.\"

    Figure 5-4 \u00a0 Queue's First-In-First-Out Rule

    "},{"location":"chapter_stack_and_queue/queue/#521-common-operations-on-queue","title":"5.2.1 \u00a0 Common Operations on Queue","text":"

    The common operations on a queue are shown in the Table 5-2 . Note that method names may vary across different programming languages. Here, we use the same naming convention as that used for stacks.

    Table 5-2 \u00a0 Efficiency of Queue Operations

    Method Name Description Time Complexity push() Enqueue an element, add it to the tail \\(O(1)\\) pop() Dequeue the head element \\(O(1)\\) peek() Access the head element \\(O(1)\\)

    We can directly use the ready-made queue classes in programming languages:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig queue.py
    from collections import deque\n\n# Initialize the queue\n# In Python, we generally use the deque class as a queue\n# Although queue.Queue() is a pure queue class, it's not very user-friendly, so it's not recommended\nque: deque[int] = deque()\n\n# Enqueue elements\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# Access the first element\nfront: int = que[0]\n\n# Dequeue an element\npop: int = que.popleft()\n\n# Get the length of the queue\nsize: int = len(que)\n\n# Check if the queue is empty\nis_empty: bool = len(que) == 0\n
    queue.cpp
    /* Initialize the queue */\nqueue<int> queue;\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access the first element*/\nint front = queue.front();\n\n/* Dequeue an element */\nqueue.pop();\n\n/* Get the length of the queue */\nint size = queue.size();\n\n/* Check if the queue is empty */\nbool empty = queue.empty();\n
    queue.java
    /* Initialize the queue */\nQueue<Integer> queue = new LinkedList<>();\n\n/* Enqueue elements */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* Access the first element */\nint peek = queue.peek();\n\n/* Dequeue an element */\nint pop = queue.poll();\n\n/* Get the length of the queue */\nint size = queue.size();\n\n/* Check if the queue is empty */\nboolean isEmpty = queue.isEmpty();\n
    queue.cs
    /* Initialize the queue */\nQueue<int> queue = new();\n\n/* Enqueue elements */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* Access the first element */\nint peek = queue.Peek();\n\n/* Dequeue an element */\nint pop = queue.Dequeue();\n\n/* Get the length of the queue */\nint size = queue.Count;\n\n/* Check if the queue is empty */\nbool isEmpty = queue.Count == 0;\n
    queue_test.go
    /* Initialize the queue */\n// In Go, use list as a queue\nqueue := list.New()\n\n/* Enqueue elements */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* Access the first element */\npeek := queue.Front()\n\n/* Dequeue an element */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* Get the length of the queue */\nsize := queue.Len()\n\n/* Check if the queue is empty */\nisEmpty := queue.Len() == 0\n
    queue.swift
    /* Initialize the queue */\n// Swift does not have a built-in queue class, so Array can be used as a queue\nvar queue: [Int] = []\n\n/* Enqueue elements */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* Access the first element */\nlet peek = queue.first!\n\n/* Dequeue an element */\n// Since it's an array, removeFirst has a complexity of O(n)\nlet pool = queue.removeFirst()\n\n/* Get the length of the queue */\nlet size = queue.count\n\n/* Check if the queue is empty */\nlet isEmpty = queue.isEmpty\n
    queue.js
    /* Initialize the queue */\n// JavaScript does not have a built-in queue, so Array can be used as a queue\nconst queue = [];\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access the first element */\nconst peek = queue[0];\n\n/* Dequeue an element */\n// Since the underlying structure is an array, shift() method has a time complexity of O(n)\nconst pop = queue.shift();\n\n/* Get the length of the queue */\nconst size = queue.length;\n\n/* Check if the queue is empty */\nconst empty = queue.length === 0;\n
    queue.ts
    /* Initialize the queue */\n// TypeScript does not have a built-in queue, so Array can be used as a queue \nconst queue: number[] = [];\n\n/* Enqueue elements */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* Access the first element */\nconst peek = queue[0];\n\n/* Dequeue an element */\n// Since the underlying structure is an array, shift() method has a time complexity of O(n)\nconst pop = queue.shift();\n\n/* Get the length of the queue */\nconst size = queue.length;\n\n/* Check if the queue is empty */\nconst empty = queue.length === 0;\n
    queue.dart
    /* Initialize the queue */\n// In Dart, the Queue class is a double-ended queue but can be used as a queue\nQueue<int> queue = Queue();\n\n/* Enqueue elements */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* Access the first element */\nint peek = queue.first;\n\n/* Dequeue an element */\nint pop = queue.removeFirst();\n\n/* Get the length of the queue */\nint size = queue.length;\n\n/* Check if the queue is empty */\nbool isEmpty = queue.isEmpty;\n
    queue.rs
    /* Initialize the double-ended queue */\n// In Rust, use a double-ended queue as a regular queue\nlet mut deque: VecDeque<u32> = VecDeque::new();\n\n/* Enqueue elements */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* Access the first element */\nif let Some(front) = deque.front() {\n}\n\n/* Dequeue an element */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* Get the length of the queue */\nlet size = deque.len();\n\n/* Check if the queue is empty */\nlet is_empty = deque.is_empty();\n
    queue.c
    // C does not provide a built-in queue\n
    queue.kt
    \n
    queue.zig
    \n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/queue/#522-implementing-a-queue","title":"5.2.2 \u00a0 Implementing a Queue","text":"

    To implement a queue, we need a data structure that allows adding elements at one end and removing them at the other. Both linked lists and arrays meet this requirement.

    "},{"location":"chapter_stack_and_queue/queue/#1-implementation-based-on-a-linked-list","title":"1. \u00a0 Implementation Based on a Linked List","text":"

    As shown in the Figure 5-5 , we can consider the \"head node\" and \"tail node\" of a linked list as the \"front\" and \"rear\" of the queue, respectively. It is stipulated that nodes can only be added at the rear and removed at the front.

    LinkedListQueuepush()pop()

    Figure 5-5 \u00a0 Implementing Queue with Linked List for Enqueue and Dequeue Operations

    Below is the code for implementing a queue using a linked list:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_queue.py
    class LinkedListQueue:\n    \"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._front: ListNode | None = None  # \u5934\u8282\u70b9 front\n        self._rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\n        self._size: int = 0\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return not self._front\n\n    def push(self, num: int):\n        \"\"\"\u5165\u961f\"\"\"\n        # \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        node = ListNode(num)\n        # \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if self._front is None:\n            self._front = node\n            self._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:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u961f\"\"\"\n        num = self.peek()\n        # \u5220\u9664\u5934\u8282\u70b9\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\n        return self._front.val\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n
    linkedlist_queue.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        freeMemoryLinkedList(front);\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    void push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode *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\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n        else {\n            rear->next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    int pop() {\n        int num = peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        ListNode *tmp = front;\n        front = front->next;\n        // \u91ca\u653e\u5185\u5b58\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        return front->val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        ListNode *node = front;\n        vector<int> res(size());\n        for (int i = 0; i < res.size(); i++) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_queue.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f */\n    public void push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode 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\n        if (front == null) {\n            front = node;\n            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 {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int pop() {\n        int num = peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    ListNode? front, rear;  // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear \n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u961f */\n    public void Push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode node = new(num);\n        // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if (front == null) {\n            front = node;\n            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 if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int Pop() {\n        int num = Peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i < res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* \u5165\u961f */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* \u51fa\u961f */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n
    linkedlist_queue.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private var front: ListNode? // \u5934\u8282\u70b9\n    private var rear: ListNode? // \u5c3e\u8282\u70b9\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f */\n    func push(num: Int) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        let 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\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* \u51fa\u961f */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return front!.val\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\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;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        const 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\n        if (!this.#front) {\n            this.#front = node;\n            this.#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 {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop() {\n        const num = this.peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek() {\n        if (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.#front.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private front: ListNode | null; // \u5934\u8282\u70b9 front\n    private rear: ListNode | null; // \u5c3e\u8282\u70b9 rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num: number): void {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        const 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\n        if (!this.front) {\n            this.front = node;\n            this.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 {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        // \u5220\u9664\u5934\u8282\u70b9\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek(): number {\n        if (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.front!.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array<number>(this.size);\n        for (let i = 0; i < res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.dart
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n  ListNode? _front; // \u5934\u8282\u70b9 _front\n  ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\n  int _queSize = 0; // \u961f\u5217\u957f\u5ea6\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u5165\u961f */\n  void push(int _num) {\n    // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 _num\n    final node = ListNode(_num);\n    // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n    if (_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\n  /* \u51fa\u961f */\n  int pop() {\n    final int _num = peek();\n    // \u5220\u9664\u5934\u8282\u70b9\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('\u961f\u5217\u4e3a\u7a7a');\n    }\n    return _front!.val;\n  }\n\n  /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n  List<int> toArray() {\n    ListNode? node = _front;\n    final List<int> queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n
    linkedlist_queue.rs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\n#[allow(dead_code)]\npub struct LinkedListQueue<T> {\n    front: Option<Rc<RefCell<ListNode<T>>>>, // \u5934\u8282\u70b9 front\n    rear: Option<Rc<RefCell<ListNode<T>>>>,  // \u5c3e\u8282\u70b9 rear\n    que_size: usize,                         // \u961f\u5217\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListQueue<T> {\n    pub fn new() -> Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.que_size;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u961f */\n    pub fn push(&mut self, num: T) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n            Some(old_rear) => {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n            None => {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* \u51fa\u961f */\n    pub fn pop(&mut self) -> Option<T> {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) => {\n                    self.front = Some(new_front);\n                }\n                None => {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            Rc::try_unwrap(old_front).ok().unwrap().into_inner().val\n        })\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.front.as_ref()\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.insert(0, node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_queue.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue->front = NULL;\n    queue->rear = NULL;\n    queue->queSize = 0;\n    return queue;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // \u91ca\u653e\u6240\u6709\u8282\u70b9\n    while (queue->front != NULL) {\n        ListNode *tmp = queue->front;\n        queue->front = queue->front->next;\n        free(tmp);\n    }\n    // \u91ca\u653e queue \u7ed3\u6784\u4f53\n    free(queue);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(LinkedListQueue *queue) {\n    return queue->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* \u5165\u961f */\nvoid push(LinkedListQueue *queue, int num) {\n    // \u5c3e\u8282\u70b9\u5904\u6dfb\u52a0 node\n    ListNode *node = newListNode(num);\n    // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n    if (queue->front == NULL) {\n        queue->front = node;\n        queue->rear = node;\n    }\n    // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n    else {\n        queue->rear->next = node;\n        queue->rear = node;\n    }\n    queue->queSize++;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) && queue->front);\n    return queue->front->val;\n}\n\n/* \u51fa\u961f */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue->front;\n    queue->front = queue->front->next;\n    free(tmp);\n    queue->queSize--;\n    return num;\n}\n\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue->queSize);\n    // \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue->front; i < queue->queSize; i++) {\n        arr[i] = node->val;\n        node = node->next;\n    }\n    printArray(arr, queue->queSize);\n    free(arr);\n}\n
    linkedlist_queue.kt
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue(\n    // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u961f */\n    fun push(num: Int) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        val node = ListNode(num)\n        // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if (front == null) {\n            front = node\n            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 {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* \u51fa\u961f */\n    fun pop(): Int {\n        val num = peek()\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!.value\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!.value\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_queue.rb
    [class]{LinkedListQueue}-[func]{}\n
    linkedlist_queue.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\nfn LinkedListQueue(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        front: ?*inc.ListNode(T) = null,                // \u5934\u8282\u70b9 front\n        rear: ?*inc.ListNode(T) = null,                 // \u5c3e\u8282\u70b9 rear\n        que_size: usize = 0,                            // \u961f\u5217\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.front = null;\n            self.rear = null;\n            self.que_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.que_size;\n        }\n\n        // \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.size() == 0) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\n            return self.front.?.val;\n        }  \n\n        // \u5165\u961f\n        pub fn push(self: *Self, num: T) !void {\n            // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n            var node = try self.mem_allocator.create(inc.ListNode(T));\n            node.init(num);\n            // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n            if (self.front == null) {\n                self.front = node;\n                self.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 {\n                self.rear.?.next = node;\n                self.rear = node;\n            }\n            self.que_size += 1;\n        } \n\n        // \u51fa\u961f\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            // \u5220\u9664\u5934\u8282\u70b9\n            self.front = self.front.?.next;\n            self.que_size -= 1;\n            return num;\n        } \n\n        // \u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.front;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[i] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/queue/#2-implementation-based-on-an-array","title":"2. \u00a0 Implementation Based on an Array","text":"

    Deleting the first element in an array has a time complexity of \\(O(n)\\), which would make the dequeue operation inefficient. However, this problem can be cleverly avoided as follows.

    We use a variable front to indicate the index of the front element and maintain a variable size to record the queue's length. Define rear = front + size, which points to the position immediately following the tail element.

    With this design, the effective interval of elements in the array is [front, rear - 1]. The implementation methods for various operations are shown in the Figure 5-6 .

    • Enqueue operation: Assign the input element to the rear index and increase size by 1.
    • Dequeue operation: Simply increase front by 1 and decrease size by 1.

    Both enqueue and dequeue operations only require a single operation, each with a time complexity of \\(O(1)\\).

    ArrayQueuepush()pop()

    Figure 5-6 \u00a0 Implementing Queue with Array for Enqueue and Dequeue Operations

    You might notice a problem: as enqueue and dequeue operations are continuously performed, both front and rear move to the right and will eventually reach the end of the array and can't move further. To resolve this, we can treat the array as a \"circular array\" where connecting the end of the array back to its beginning.

    In a circular array, front or rear needs to loop back to the start of the array upon reaching the end. This cyclical pattern can be achieved with a \"modulo operation\" as shown in the code below:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_queue.py
    class ArrayQueue:\n    \"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._nums: list[int] = [0] * size  # \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n        self._front: int = 0  # \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n        self._size: int = 0  # \u961f\u5217\u957f\u5ea6\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\n        return len(self._nums)\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"\u961f\u5217\u5df2\u6ee1\")\n        # \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        # \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        rear: int = (self._front + self._size) % self.capacity()\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u961f\"\"\"\n        num: int = self.peek()\n        # \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\n        return self._nums[self._front]\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n
    array_queue.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n  private:\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u961f\u5217\u957f\u5ea6\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n\n  public:\n    ArrayQueue(int capacity) {\n        // \u521d\u59cb\u5316\u6570\u7ec4\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout << \"\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % queCapacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    int pop() {\n        int num = peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        return nums[front];\n    }\n\n    /* \u5c06\u6570\u7ec4\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> arr(queSize);\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n
    array_queue.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private int[] nums; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private int queSize; // \u961f\u5217\u957f\u5ea6\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % capacity();\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int pop() {\n        int num = peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    public int[] toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n
    array_queue.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize; // \u961f\u5217\u957f\u5ea6\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % Capacity();\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int Pop() {\n        int num = Peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n
    array_queue.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntype arrayQueue struct {\n    nums        []int // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    queSize     int   // \u961f\u5217\u957f\u5ea6\n    queCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* \u5165\u961f */\nfunc (q *arrayQueue) push(num int) {\n    // \u5f53 rear == queCapacity \u8868\u793a\u961f\u5217\u5df2\u6ee1\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    rear := (q.front + q.queSize) % q.queCapacity\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* \u51fa\u961f */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear >= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n
    array_queue.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var _size: Int // \u961f\u5217\u957f\u5ea6\n\n    init(capacity: Int) {\n        // \u521d\u59cb\u5316\u6570\u7ec4\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    func capacity() -> Int {\n        nums.count\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        let rear = (front + size()) % capacity()\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* \u51fa\u961f */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return nums[front]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    func toArray() -> [Int] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        (front ..< front + size()).map { nums[$0 % capacity()] }\n    }\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\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        const rear = (this.#front + this.size) % this.capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop() {\n        const num = this.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek() {\n        if (this.isEmpty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.#nums[this.#front];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i < this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n
    array_queue.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private queSize: number; // \u961f\u5217\u957f\u5ea6\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        const rear = (this.front + this.queSize) % this.capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop(): number {\n        const num = this.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.nums[this.front];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray(): number[] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i < this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n
    array_queue.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n  late List<int> _nums; // \u7528\u4e8e\u50a8\u5b58\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n  late int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n  late int _queSize; // \u961f\u5217\u957f\u5ea6\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u5165\u961f */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"\u961f\u5217\u5df2\u6ee1\");\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    int rear = (_front + _queSize) % capaCity();\n    // \u5c06 _num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* \u51fa\u961f */\n  int pop() {\n    int _num = peek();\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"\u961f\u5217\u4e3a\u7a7a\");\n    }\n    return _nums[_front];\n  }\n\n  /* \u8fd4\u56de Array */\n  List<int> toArray() {\n    // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    final List<int> res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i < _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n
    array_queue.rs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nstruct ArrayQueue {\n    nums: Vec<i32>,    // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front: i32,        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    que_size: i32,     // \u961f\u5217\u957f\u5ea6\n    que_capacity: i32, // \u961f\u5217\u5bb9\u91cf\n}\n\nimpl ArrayQueue {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(capacity: i32) -> ArrayQueue {\n        ArrayQueue {\n            nums: vec![0; capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    fn capacity(&self) -> i32 {\n        self.que_capacity\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fn size(&self) -> i32 {\n        self.que_size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fn is_empty(&self) -> bool {\n        self.que_size == 0\n    }\n\n    /* \u5165\u961f */\n    fn push(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* \u51fa\u961f */\n    fn pop(&mut self) -> i32 {\n        let num = self.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fn peek(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    fn to_vector(&self) -> Vec<i32> {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![0; self.que_size as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n
    array_queue.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntypedef struct {\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n} ArrayQueue;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // \u521d\u59cb\u5316\u6570\u7ec4\n    queue->queCapacity = capacity;\n    queue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);\n    queue->front = queue->queSize = 0;\n    return queue;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue->nums);\n    free(queue);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(ArrayQueue *queue) {\n    return queue->queCapacity;\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(ArrayQueue *queue) {\n    return queue->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(ArrayQueue *queue) {\n    return queue->queSize == 0;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue->nums[queue->front];\n}\n\n/* \u5165\u961f */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    int rear = (queue->front + queue->queSize) % queue->queCapacity;\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    queue->nums[rear] = num;\n    queue->queSize++;\n}\n\n/* \u51fa\u961f */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    queue->front = (queue->front + 1) % queue->queCapacity;\n    queue->queSize--;\n    return num;\n}\n
    array_queue.kt
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue(capacity: Int) {\n    private val nums = IntArray(capacity) // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var queSize = 0 // \u961f\u5217\u957f\u5ea6\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* \u5165\u961f */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        val rear = (front + queSize) % capacity()\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        queSize++\n    }\n\n    /* \u51fa\u961f */\n    fun pop(): Int {\n        val num = peek()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    fun toArray(): IntArray {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i < queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n
    array_queue.rb
    [class]{ArrayQueue}-[func]{}\n
    array_queue.zig
    // \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\nfn ArrayQueue(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        nums: []T = undefined,                          // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4     \n        cap: usize = 0,                                 // \u961f\u5217\u5bb9\u91cf\n        front: usize = 0,                               // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n        queSize: usize = 0,                             // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6570\u7ec4\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.cap = cap;\n            self.nums = try self.mem_allocator.alloc(T, self.cap);\n            @memset(self.nums, @as(T, 0));\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\n        pub fn capacity(self: *Self) usize {\n            return self.cap;\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.queSize;\n        }\n\n        // \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.queSize == 0;\n        }\n\n        // \u5165\u961f\n        pub fn push(self: *Self, num: T) !void {\n            if (self.size() == self.capacity()) {\n                std.debug.print(\"\u961f\u5217\u5df2\u6ee1\\n\", .{});\n                return;\n            }\n            // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n            // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n            var rear = (self.front + self.queSize) % self.capacity();\n            // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n            self.nums[rear] = num;\n            self.queSize += 1;\n        } \n\n        // \u51fa\u961f\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n            self.front = (self.front + 1) % self.capacity();\n            self.queSize -= 1;\n            return num;\n        } \n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\n            return self.nums[self.front];\n        } \n\n        // \u8fd4\u56de\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            var j: usize = self.front;\n            while (i < self.size()) : ({ i += 1; j += 1; }) {\n                res[i] = self.nums[j % self.capacity()];\n            }\n            return res;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    The above implementation of the queue still has its limitations: its length is fixed. However, this issue is not difficult to resolve. We can replace the array with a dynamic array that can expand itself if needed. Interested readers can try to implement this themselves.

    The comparison of the two implementations is consistent with that of the stack and is not repeated here.

    "},{"location":"chapter_stack_and_queue/queue/#523-typical-applications-of-queue","title":"5.2.3 \u00a0 Typical Applications of Queue","text":"
    • Amazon Orders. After shoppers place orders, these orders join a queue, and the system processes them in order. During events like Singles' Day, a massive number of orders are generated in a short time, making high concurrency a key challenge for engineers.
    • Various To-Do Lists. Any scenario requiring a \"first-come, first-served\" functionality, such as a printer's task queue or a restaurant's food delivery queue, can effectively maintain the order of processing with a queue.
    "},{"location":"chapter_stack_and_queue/stack/","title":"5.1 \u00a0 Stack","text":"

    A \"Stack\" is a linear data structure that follows the principle of Last-In-First-Out (LIFO).

    We can compare a stack to a pile of plates on a table. To access the bottom plate, one must first remove the plates on top. By replacing the plates with various types of elements (such as integers, characters, objects, etc.), we obtain the data structure known as a stack.

    As shown in the Figure 5-1 , we refer to the top of the pile of elements as the \"top of the stack\" and the bottom as the \"bottom of the stack.\" The operation of adding elements to the top of the stack is called \"push,\" and the operation of removing the top element is called \"pop.\"

    Figure 5-1 \u00a0 Stack's Last-In-First-Out Rule

    "},{"location":"chapter_stack_and_queue/stack/#511-common-operations-on-stack","title":"5.1.1 \u00a0 Common Operations on Stack","text":"

    The common operations on a stack are shown in the Table 5-1 . The specific method names depend on the programming language used. Here, we use push(), pop(), and peek() as examples.

    Table 5-1 \u00a0 Efficiency of Stack Operations

    Method Description Time Complexity push() Push an element onto the stack (add to the top) \\(O(1)\\) pop() Pop the top element from the stack \\(O(1)\\) peek() Access the top element of the stack \\(O(1)\\)

    Typically, we can directly use the stack class built into the programming language. However, some languages may not specifically provide a stack class. In these cases, we can use the language's \"array\" or \"linked list\" as a stack and ignore operations that are not related to stack logic in the program.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinZig stack.py
    # Initialize the stack\n# Python does not have a built-in stack class, so a list can be used as a stack\nstack: list[int] = []\n\n# Push elements onto the stack\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# Access the top element of the stack\npeek: int = stack[-1]\n\n# Pop an element from the stack\npop: int = stack.pop()\n\n# Get the length of the stack\nsize: int = len(stack)\n\n# Check if the stack is empty\nis_empty: bool = len(stack) == 0\n
    stack.cpp
    /* Initialize the stack */\nstack<int> stack;\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nint top = stack.top();\n\n/* Pop an element from the stack */\nstack.pop(); // No return value\n\n/* Get the length of the stack */\nint size = stack.size();\n\n/* Check if the stack is empty */\nbool empty = stack.empty();\n
    stack.java
    /* Initialize the stack */\nStack<Integer> stack = new Stack<>();\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nint peek = stack.peek();\n\n/* Pop an element from the stack */\nint pop = stack.pop();\n\n/* Get the length of the stack */\nint size = stack.size();\n\n/* Check if the stack is empty */\nboolean isEmpty = stack.isEmpty();\n
    stack.cs
    /* Initialize the stack */\nStack<int> stack = new();\n\n/* Push elements onto the stack */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* Access the top element of the stack */\nint peek = stack.Peek();\n\n/* Pop an element from the stack */\nint pop = stack.Pop();\n\n/* Get the length of the stack */\nint size = stack.Count;\n\n/* Check if the stack is empty */\nbool isEmpty = stack.Count == 0;\n
    stack_test.go
    /* Initialize the stack */\n// In Go, it is recommended to use a Slice as a stack\nvar stack []int\n\n/* Push elements onto the stack */\nstack = append(stack, 1)\nstack = append(stack, 3)\nstack = append(stack, 2)\nstack = append(stack, 5)\nstack = append(stack, 4)\n\n/* Access the top element of the stack */\npeek := stack[len(stack)-1]\n\n/* Pop an element from the stack */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* Get the length of the stack */\nsize := len(stack)\n\n/* Check if the stack is empty */\nisEmpty := len(stack) == 0\n
    stack.swift
    /* Initialize the stack */\n// Swift does not have a built-in stack class, so Array can be used as a stack\nvar stack: [Int] = []\n\n/* Push elements onto the stack */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* Access the top element of the stack */\nlet peek = stack.last!\n\n/* Pop an element from the stack */\nlet pop = stack.removeLast()\n\n/* Get the length of the stack */\nlet size = stack.count\n\n/* Check if the stack is empty */\nlet isEmpty = stack.isEmpty\n
    stack.js
    /* Initialize the stack */\n// JavaScript does not have a built-in stack class, so Array can be used as a stack\nconst stack = [];\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nconst peek = stack[stack.length-1];\n\n/* Pop an element from the stack */\nconst pop = stack.pop();\n\n/* Get the length of the stack */\nconst size = stack.length;\n\n/* Check if the stack is empty */\nconst is_empty = stack.length === 0;\n
    stack.ts
    /* Initialize the stack */\n// TypeScript does not have a built-in stack class, so Array can be used as a stack\nconst stack: number[] = [];\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nconst peek = stack[stack.length - 1];\n\n/* Pop an element from the stack */\nconst pop = stack.pop();\n\n/* Get the length of the stack */\nconst size = stack.length;\n\n/* Check if the stack is empty */\nconst is_empty = stack.length === 0;\n
    stack.dart
    /* Initialize the stack */\n// Dart does not have a built-in stack class, so List can be used as a stack\nList<int> stack = [];\n\n/* Push elements onto the stack */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* Access the top element of the stack */\nint peek = stack.last;\n\n/* Pop an element from the stack */\nint pop = stack.removeLast();\n\n/* Get the length of the stack */\nint size = stack.length;\n\n/* Check if the stack is empty */\nbool isEmpty = stack.isEmpty;\n
    stack.rs
    /* Initialize the stack */\n// Use Vec as a stack\nlet mut stack: Vec<i32> = Vec::new();\n\n/* Push elements onto the stack */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* Access the top element of the stack */\nlet top = stack.last().unwrap();\n\n/* Pop an element from the stack */\nlet pop = stack.pop().unwrap();\n\n/* Get the length of the stack */\nlet size = stack.len();\n\n/* Check if the stack is empty */\nlet is_empty = stack.is_empty();\n
    stack.c
    // C does not provide a built-in stack\n
    stack.kt
    \n
    stack.zig
    \n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/stack/#512-implementing-a-stack","title":"5.1.2 \u00a0 Implementing a Stack","text":"

    To gain a deeper understanding of how a stack operates, let's try implementing a stack class ourselves.

    A stack follows the principle of Last-In-First-Out, which means we can only add or remove elements at the top of the stack. However, both arrays and linked lists allow adding and removing elements at any position, therefore a stack can be seen as a restricted array or linked list. In other words, we can \"shield\" certain irrelevant operations of an array or linked list, aligning their external behavior with the characteristics of a stack.

    "},{"location":"chapter_stack_and_queue/stack/#1-implementation-based-on-linked-list","title":"1. \u00a0 Implementation Based on Linked List","text":"

    When implementing a stack using a linked list, we can consider the head node of the list as the top of the stack and the tail node as the bottom of the stack.

    As shown in the Figure 5-2 , for the push operation, we simply insert elements at the head of the linked list. This method of node insertion is known as \"head insertion.\" For the pop operation, we just need to remove the head node from the list.

    LinkedListStackpush()pop()

    Figure 5-2 \u00a0 Implementing Stack with Linked List for Push and Pop Operations

    Below is an example code for implementing a stack based on a linked list:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_stack.py
    class LinkedListStack:\n    \"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return not self._peek\n\n    def push(self, val: int):\n        \"\"\"\u5165\u6808\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u6808\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._peek.val\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n
    linkedlist_stack.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int stkSize;        // \u6808\u7684\u957f\u5ea6\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    int size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node->next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop->next;\n        // \u91ca\u653e\u5185\u5b58\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"\u6808\u4e3a\u7a7a\");\n        return stackTop->val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        ListNode *node = stackTop;\n        vector<int> res(size());\n        for (int i = res.size() - 1; i >= 0; i--) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_stack.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private ListNode stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private int stkSize = 0; // \u6808\u7684\u957f\u5ea6\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i >= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    ListNode? stackPeek;  // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int stkSize = 0;   // \u6808\u7684\u957f\u5ea6\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i >= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u6808 */\nfunc newLinkedListStack() *linkedListStack {\n    return &linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* \u5165\u6808 */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* \u51fa\u6808 */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n
    linkedlist_stack.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private var _peek: ListNode? // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private var _size: Int // \u6808\u7684\u957f\u5ea6\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u6808 */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* \u51fa\u6808 */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return _peek!.val\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\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\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    peek() {\n        if (!this.#stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stackPeek.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i >= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private stkSize: number = 0; // \u6808\u7684\u957f\u5ea6\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stackPeek.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array<number>(this.size);\n        for (let i = res.length - 1; i >= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.dart
    /* \u57fa\u4e8e\u94fe\u8868\u7c7b\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n  ListNode? _stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n  int _stkSize = 0; // \u6808\u7684\u957f\u5ea6\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n  int size() {\n    return _stkSize;\n  }\n\n  /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* \u5165\u6808 */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* \u51fa\u6808 */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a List \u5e76\u8fd4\u56de */\n  List<int> toList() {\n    ListNode? node = _stackPeek;\n    List<int> list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n
    linkedlist_stack.rs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\n#[allow(dead_code)]\npub struct LinkedListStack<T> {\n    stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    stk_size: usize,                              // \u6808\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListStack<T> {\n    pub fn new() -> Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.stk_size;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    pub fn push(&mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* \u51fa\u6808 */\n    pub fn pop(&mut self) -> Option<T> {\n        self.stack_peek.take().map(|old_head| {\n            match old_head.borrow_mut().next.take() {\n                Some(new_head) => {\n                    self.stack_peek = Some(new_head);\n                }\n                None => {\n                    self.stack_peek = None;\n                }\n            }\n            self.stk_size -= 1;\n            Rc::try_unwrap(old_head).ok().unwrap().into_inner().val\n        })\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.stack_peek.as_ref()\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.push(node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_stack.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\ntypedef struct {\n    ListNode *top; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int size;      // \u6808\u7684\u957f\u5ea6\n} LinkedListStack;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s->top = NULL;\n    s->size = 0;\n    return s;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s->top) {\n        ListNode *n = s->top->next;\n        free(s->top);\n        s->top = n;\n    }\n    free(s);\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(LinkedListStack *s) {\n    return s->size;\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* \u5165\u6808 */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node->next = s->top; // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6307\u9488\u57df\n    node->val = num;     // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6570\u636e\u57df\n    s->top = node;       // \u66f4\u65b0\u6808\u9876\n    s->size++;           // \u66f4\u65b0\u6808\u5927\u5c0f\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(LinkedListStack *s) {\n    if (s->size == 0) {\n        printf(\"\u6808\u4e3a\u7a7a\\n\");\n        return INT_MAX;\n    }\n    return s->top->val;\n}\n\n/* \u51fa\u6808 */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s->top;\n    s->top = s->top->next;\n    // \u91ca\u653e\u5185\u5b58\n    free(tmp);\n    s->size--;\n    return val;\n}\n
    linkedlist_stack.kt
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private var stkSize: Int = 0 // \u6808\u7684\u957f\u5ea6\n) {\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* \u51fa\u6808 */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--;\n        return num\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?.value\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?.value!!\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_stack.rb
    [class]{LinkedListStack}-[func]{}\n
    linkedlist_stack.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\nfn LinkedListStack(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        stack_top: ?*inc.ListNode(T) = null,             // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n        stk_size: usize = 0,                             // \u6808\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,    // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.stack_top = null;\n            self.stk_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u6808\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.stk_size;\n        }\n\n        // \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u6808\u9876\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.size() == 0) @panic(\"\u6808\u4e3a\u7a7a\");\n            return self.stack_top.?.val;\n        }  \n\n        // \u5165\u6808\n        pub fn push(self: *Self, num: T) !void {\n            var node = try self.mem_allocator.create(inc.ListNode(T));\n            node.init(num);\n            node.next = self.stack_top;\n            self.stack_top = node;\n            self.stk_size += 1;\n        } \n\n        // \u51fa\u6808\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            self.stack_top = self.stack_top.?.next;\n            self.stk_size -= 1;\n            return num;\n        } \n\n        // \u5c06\u6808\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.stack_top;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[res.len - i - 1] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/stack/#2-implementation-based-on-array","title":"2. \u00a0 Implementation Based on Array","text":"

    When implementing a stack using an array, we can consider the end of the array as the top of the stack. As shown in the Figure 5-3 , push and pop operations correspond to adding and removing elements at the end of the array, respectively, both with a time complexity of \\(O(1)\\).

    ArrayStackpush()pop()

    Figure 5-3 \u00a0 Implementing Stack with Array for Push and Pop Operations

    Since the elements to be pushed onto the stack may continuously increase, we can use a dynamic array, thus avoiding the need to handle array expansion ourselves. Here is an example code:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_stack.py
    class ArrayStack:\n    \"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._stack == []\n\n    def push(self, item: int):\n        \"\"\"\u5165\u6808\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u6808\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._stack.pop()\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._stack[-1]\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        return self._stack\n
    array_stack.cpp
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n  private:\n    vector<int> stack;\n\n  public:\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    int size() {\n        return stack.size();\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* \u51fa\u6808 */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"\u6808\u4e3a\u7a7a\");\n        return stack.back();\n    }\n\n    /* \u8fd4\u56de Vector */\n    vector<int> toVector() {\n        return stack;\n    }\n};\n
    array_stack.java
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private ArrayList<Integer> stack;\n\n    public ArrayStack() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = new ArrayList<>();\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int size() {\n        return stack.size();\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* \u51fa\u6808 */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n
    array_stack.cs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    List<int> stack;\n    public ArrayStack() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* \u51fa\u6808 */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n
    array_stack.go
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntype arrayStack struct {\n    data []int // \u6570\u636e\n}\n\n/* \u521d\u59cb\u5316\u6808 */\nfunc newArrayStack() *arrayStack {\n    return &arrayStack{\n        // \u8bbe\u7f6e\u6808\u7684\u957f\u5ea6\u4e3a 0\uff0c\u5bb9\u91cf\u4e3a 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* \u6808\u7684\u957f\u5ea6 */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* \u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* \u5165\u6808 */\nfunc (s *arrayStack) push(v int) {\n    // \u5207\u7247\u4f1a\u81ea\u52a8\u6269\u5bb9\n    s.data = append(s.data, v)\n}\n\n/* \u51fa\u6808 */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* \u83b7\u53d6\u6808\u9876\u5143\u7d20 */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n
    array_stack.swift
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = []\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        stack.count\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        stack.isEmpty\n    }\n\n    /* \u5165\u6808 */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* \u51fa\u6808 */\n    @discardableResult\n    func pop() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return stack.removeLast()\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return stack.last!\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        stack\n    }\n}\n
    array_stack.js
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    pop() {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stack.pop();\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    top() {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n
    array_stack.ts
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stack.pop();\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        return this.stack;\n    }\n}\n
    array_stack.dart
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n  late List<int> _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n  int size() {\n    return _stack.length;\n  }\n\n  /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* \u5165\u6808 */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* \u51fa\u6808 */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stack.last;\n  }\n\n  /* \u5c06\u6808\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n  List<int> toArray() => _stack;\n}\n
    array_stack.rs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nstruct ArrayStack<T> {\n    stack: Vec<T>,\n}\n\nimpl<T> ArrayStack<T> {\n    /* \u521d\u59cb\u5316\u6808 */\n    fn new() -> ArrayStack<T> {\n        ArrayStack::<T> {\n            stack: Vec::<T>::new(),\n        }\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fn size(&self) -> usize {\n        self.stack.len()\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fn is_empty(&self) -> bool {\n        self.size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fn push(&mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    fn pop(&mut self) -> Option<T> {\n        self.stack.pop()\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fn peek(&self) -> Option<&T> {\n        if self.is_empty() {\n            panic!(\"\u6808\u4e3a\u7a7a\")\n        };\n        self.stack.last()\n    }\n\n    /* \u8fd4\u56de &Vec */\n    fn to_array(&self) -> &Vec<T> {\n        &self.stack\n    }\n}\n
    array_stack.c
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5927\u5bb9\u91cf\uff0c\u907f\u514d\u6269\u5bb9\n    stack->data = malloc(sizeof(int) * MAX_SIZE);\n    stack->size = 0;\n    return stack;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack->data);\n    free(stack);\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(ArrayStack *stack) {\n    return stack->size;\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(ArrayStack *stack) {\n    return stack->size == 0;\n}\n\n/* \u5165\u6808 */\nvoid push(ArrayStack *stack, int num) {\n    if (stack->size == MAX_SIZE) {\n        printf(\"\u6808\u5df2\u6ee1\\n\");\n        return;\n    }\n    stack->data[stack->size] = num;\n    stack->size++;\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(ArrayStack *stack) {\n    if (stack->size == 0) {\n        printf(\"\u6808\u4e3a\u7a7a\\n\");\n        return INT_MAX;\n    }\n    return stack->data[stack->size - 1];\n}\n\n/* \u51fa\u6808 */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack->size--;\n    return val;\n}\n
    array_stack.kt
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n    private val stack = ArrayList<Int>()\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* \u51fa\u6808 */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): Array<Any> {\n        return stack.toArray()\n    }\n}\n
    array_stack.rb
    [class]{ArrayStack}-[func]{}\n
    array_stack.zig
    // \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\nfn ArrayStack(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        stack: ?std.ArrayList(T) = null,     \n\n        // \u6784\u9020\u65b9\u6cd5\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) void {\n            if (self.stack == null) {\n                self.stack = std.ArrayList(T).init(allocator);\n            }\n        }\n\n        // \u6790\u6784\u65b9\u6cd5\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.stack == null) return;\n            self.stack.?.deinit();\n        }\n\n        // \u83b7\u53d6\u6808\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.stack.?.items.len;\n        }\n\n        // \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u6808\u9876\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u6808\u4e3a\u7a7a\");\n            return self.stack.?.items[self.size() - 1];\n        }  \n\n        // \u5165\u6808\n        pub fn push(self: *Self, num: T) !void {\n            try self.stack.?.append(num);\n        } \n\n        // \u51fa\u6808\n        pub fn pop(self: *Self) T {\n            var num = self.stack.?.pop();\n            return num;\n        } \n\n        // \u8fd4\u56de ArrayList\n        pub fn toList(self: *Self) std.ArrayList(T) {\n            return self.stack.?;\n        }\n    };\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_stack_and_queue/stack/#513-comparison-of-the-two-implementations","title":"5.1.3 \u00a0 Comparison of the Two Implementations","text":"

    Supported Operations

    Both implementations support all the operations defined in a stack. The array implementation additionally supports random access, but this is beyond the scope of a stack definition and is generally not used.

    Time Efficiency

    In the array-based implementation, both push and pop operations occur in pre-allocated contiguous memory, which has good cache locality and therefore higher efficiency. However, if the push operation exceeds the array capacity, it triggers a resizing mechanism, making the time complexity of that push operation \\(O(n)\\).

    In the linked list implementation, list expansion is very flexible, and there is no efficiency decrease issue as in array expansion. However, the push operation requires initializing a node object and modifying pointers, so its efficiency is relatively lower. If the elements being pushed are already node objects, then the initialization step can be skipped, improving efficiency.

    Thus, when the elements for push and pop operations are basic data types like int or double, we can draw the following conclusions:

    • The array-based stack implementation's efficiency decreases during expansion, but since expansion is a low-frequency operation, its average efficiency is higher.
    • The linked list-based stack implementation provides more stable efficiency performance.

    Space Efficiency

    When initializing a list, the system allocates an \"initial capacity,\" which might exceed the actual need; moreover, the expansion mechanism usually increases capacity by a specific factor (like doubling), which may also exceed the actual need. Therefore, the array-based stack might waste some space.

    However, since linked list nodes require extra space for storing pointers, the space occupied by linked list nodes is relatively larger.

    In summary, we cannot simply determine which implementation is more memory-efficient. It requires analysis based on specific circumstances.

    "},{"location":"chapter_stack_and_queue/stack/#514-typical-applications-of-stack","title":"5.1.4 \u00a0 Typical Applications of Stack","text":"
    • Back and forward in browsers, undo and redo in software. Every time we open a new webpage, the browser pushes the previous page onto the stack, allowing us to go back to the previous page through the back operation, which is essentially a pop operation. To support both back and forward, two stacks are needed to work together.
    • Memory management in programs. Each time a function is called, the system adds a stack frame at the top of the stack to record the function's context information. In recursive functions, the downward recursion phase keeps pushing onto the stack, while the upward backtracking phase keeps popping from the stack.
    "},{"location":"chapter_stack_and_queue/summary/","title":"5.4 \u00a0 Summary","text":""},{"location":"chapter_stack_and_queue/summary/#1-key-review","title":"1. \u00a0 Key Review","text":"
    • Stack is a data structure that follows the Last-In-First-Out (LIFO) principle and can be implemented using arrays or linked lists.
    • In terms of time efficiency, the array implementation of the stack has a higher average efficiency. However, during expansion, the time complexity for a single push operation can degrade to \\(O(n)\\). In contrast, the linked list implementation of a stack offers more stable efficiency.
    • Regarding space efficiency, the array implementation of the stack may lead to a certain degree of space wastage. However, it's important to note that the memory space occupied by nodes in a linked list is generally larger than that for elements in an array.
    • A queue is a data structure that follows the First-In-First-Out (FIFO) principle, and it can also be implemented using arrays or linked lists. The conclusions regarding time and space efficiency for queues are similar to those for stacks.
    • A double-ended queue (deque) is a more flexible type of queue that allows adding and removing elements at both ends.
    "},{"location":"chapter_stack_and_queue/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: Is the browser's forward and backward functionality implemented with a doubly linked list?

    A browser's forward and backward navigation is essentially a manifestation of the \"stack\" concept. When a user visits a new page, the page is added to the top of the stack; when they click the back button, the page is popped from the top of the stack. A double-ended queue (deque) can conveniently implement some additional operations, as mentioned in the \"Double-Ended Queue\" section.

    Q: After popping from a stack, is it necessary to free the memory of the popped node?

    If the popped node will still be used later, it's not necessary to free its memory. In languages like Java and Python that have automatic garbage collection, manual memory release is not necessary; in C and C++, manual memory release is required.

    Q: A double-ended queue seems like two stacks joined together. What are its uses?

    A double-ended queue, which is a combination of a stack and a queue or two stacks joined together, exhibits both stack and queue logic. Thus, it can implement all applications of stacks and queues while offering more flexibility.

    Q: How exactly are undo and redo implemented?

    Undo and redo operations are implemented using two stacks: Stack A for undo and Stack B for redo.

    1. Each time a user performs an operation, it is pushed onto Stack A, and Stack B is cleared.
    2. When the user executes an \"undo\", the most recent operation is popped from Stack A and pushed onto Stack B.
    3. When the user executes a \"redo\", the most recent operation is popped from Stack B and pushed back onto Stack A.
    "},{"location":"chapter_tree/","title":"Chapter 7. \u00a0 Tree","text":"

    Abstract

    The towering tree, full of vitality with its roots deep and leaves lush, branches spreading wide.

    It vividly demonstrates the form of data divide-and-conquer.

    "},{"location":"chapter_tree/#chapter-contents","title":"Chapter Contents","text":"
    • 7.1 \u00a0 Binary Tree
    • 7.2 \u00a0 Binary Tree Traversal
    • 7.3 \u00a0 Array Representation of Tree
    • 7.4 \u00a0 Binary Search Tree
    • 7.5 \u00a0 AVL Tree *
    • 7.6 \u00a0 Summary
    "},{"location":"chapter_tree/array_representation_of_tree/","title":"7.3 \u00a0 Array representation of binary trees","text":"

    Under the linked list representation, the storage unit of a binary tree is a node TreeNode, with nodes connected by pointers. The basic operations of binary trees under the linked list representation were introduced in the previous section.

    So, can we use an array to represent a binary tree? The answer is yes.

    "},{"location":"chapter_tree/array_representation_of_tree/#731-representing-perfect-binary-trees","title":"7.3.1 \u00a0 Representing perfect binary trees","text":"

    Let's analyze a simple case first. Given a perfect binary tree, we store all nodes in an array according to the order of level-order traversal, where each node corresponds to a unique array index.

    Based on the characteristics of level-order traversal, we can deduce a \"mapping formula\" between the index of a parent node and its children: If a node's index is \\(i\\), then the index of its left child is \\(2i + 1\\) and the right child is \\(2i + 2\\). The Figure 7-12 shows the mapping relationship between the indices of various nodes.

    Figure 7-12 \u00a0 Array representation of a perfect binary tree

    The mapping formula plays a role similar to the node references (pointers) in linked lists. Given any node in the array, we can access its left (right) child node using the mapping formula.

    "},{"location":"chapter_tree/array_representation_of_tree/#732-representing-any-binary-tree","title":"7.3.2 \u00a0 Representing any binary tree","text":"

    Perfect binary trees are a special case; there are often many None values in the middle levels of a binary tree. Since the sequence of level-order traversal does not include these None values, we cannot solely rely on this sequence to deduce the number and distribution of None values. This means that multiple binary tree structures can match the same level-order traversal sequence.

    As shown in the Figure 7-13 , given a non-perfect binary tree, the above method of array representation fails.

    Figure 7-13 \u00a0 Level-order traversal sequence corresponds to multiple binary tree possibilities

    To solve this problem, we can consider explicitly writing out all None values in the level-order traversal sequence. As shown in the following figure, after this treatment, the level-order traversal sequence can uniquely represent a binary tree. Example code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # Array representation of a binary tree\n# Using None to represent empty slots\ntree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]\n
    /* Array representation of a binary tree */\n// Using the maximum integer value INT_MAX to mark empty slots\nvector<int> tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};\n
    /* Array representation of a binary tree */\n// Using the Integer wrapper class allows for using null to mark empty slots\nInteger[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };\n
    /* Array representation of a binary tree */\n// Using nullable int (int?) allows for using null to mark empty slots\nint?[] tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n
    /* Array representation of a binary tree */\n// Using an any type slice, allowing for nil to mark empty slots\ntree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}\n
    /* Array representation of a binary tree */\n// Using optional Int (Int?) allows for using nil to mark empty slots\nlet tree: [Int?] = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]\n
    /* Array representation of a binary tree */\n// Using null to represent empty slots\nlet tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n
    /* Array representation of a binary tree */\n// Using null to represent empty slots\nlet tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n
    /* Array representation of a binary tree */\n// Using nullable int (int?) allows for using null to mark empty slots\nList<int?> tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];\n
    /* Array representation of a binary tree */\n// Using None to mark empty slots\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(15)];\n
    /* Array representation of a binary tree */\n// Using the maximum int value to mark empty slots, therefore, node values must not be 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
    /* Array representation of a binary tree */\n// Using null to represent empty slots\nval tree = mutableListOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n
    \n
    \n

    Figure 7-14 \u00a0 Array representation of any type of binary tree

    It's worth noting that complete binary trees are very suitable for array representation. Recalling the definition of a complete binary tree, None appears only at the bottom level and towards the right, meaning all None values definitely appear at the end of the level-order traversal sequence.

    This means that when using an array to represent a complete binary tree, it's possible to omit storing all None values, which is very convenient. The Figure 7-15 gives an example.

    Figure 7-15 \u00a0 Array representation of a complete binary tree

    The following code implements a binary tree based on array representation, including the following operations:

    • Given a node, obtain its value, left (right) child node, and parent node.
    • Obtain the preorder, inorder, postorder, and level-order traversal sequences.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_binary_tree.py
    class ArrayBinaryTree:\n    \"\"\"\u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"\u5217\u8868\u5bb9\u91cf\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -> int:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c\"\"\"\n        # \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de None \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 or i >= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -> list[int]:\n        \"\"\"\u5c42\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\n        if self.val(i) is None:\n            return\n        # \u524d\u5e8f\u904d\u5386\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # \u540e\u5e8f\u904d\u5386\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -> list[int]:\n        \"\"\"\u524d\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -> list[int]:\n        \"\"\"\u4e2d\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -> list[int]:\n        \"\"\"\u540e\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n
    array_binary_tree.cpp
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    ArrayBinaryTree(vector<int> arr) {\n        tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    int size() {\n        return tree.size();\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    int val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de INT_MAX \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    vector<int> levelOrder() {\n        vector<int> res;\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    vector<int> preOrder() {\n        vector<int> res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    vector<int> inOrder() {\n        vector<int> res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    vector<int> postOrder() {\n        vector<int> res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector<int> tree;\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    void dfs(int i, string order, vector<int> &res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (val(i) == INT_MAX)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n
    array_binary_tree.java
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    private List<Integer> tree;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayBinaryTree(List<Integer> arr) {\n        tree = new ArrayList<>(arr);\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    public int size() {\n        return tree.size();\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    public Integer val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    public List<Integer> levelOrder() {\n        List<Integer> res = new ArrayList<>();\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    private void dfs(Integer i, String order, List<Integer> res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (val(i) == null)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    public List<Integer> preOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    public List<Integer> inOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    public List<Integer> postOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n
    array_binary_tree.cs
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree(List<int?> arr) {\n    List<int?> tree = new(arr);\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    public int? Val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    public List<int> LevelOrder() {\n        List<int> res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    void DFS(int i, string order, List<int> res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (!Val(i).HasValue)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    public List<int> PreOrder() {\n        List<int> res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    public List<int> InOrder() {\n        List<int> res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    public List<int> PostOrder() {\n        List<int> res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n
    array_binary_tree.go
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* \u5217\u8868\u5bb9\u91cf */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if i < 0 || i >= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* \u5c42\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n    for i := 0; i < abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if abt.val(i) == nil {\n        return\n    }\n    // \u524d\u5e8f\u904d\u5386\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // \u4e2d\u5e8f\u904d\u5386\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // \u540e\u5e8f\u904d\u5386\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* \u524d\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &res)\n    return res\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &res)\n    return res\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &res)\n    return res\n}\n
    array_binary_tree.swift
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    func size() -> Int {\n        tree.count\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    func val(i: Int) -> Int? {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 || i >= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    func left(i: Int) -> Int {\n        2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    func right(i: Int) -> Int {\n        2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    func parent(i: Int) -> Int {\n        (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    func levelOrder() -> [Int] {\n        var res: [Int] = []\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in 0 ..< size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        guard let val = val(i: i) else {\n            return\n        }\n        // \u524d\u5e8f\u904d\u5386\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &res)\n        // \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &res)\n        // \u540e\u5e8f\u904d\u5386\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    func preOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &res)\n        return res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    func inOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &res)\n        return res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    func postOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &res)\n        return res\n    }\n}\n
    array_binary_tree.js
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    val(i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    levelOrder() {\n        let res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (let i = 0; i < this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    #dfs(i, order, res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (this.val(i) === null) return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n
    array_binary_tree.ts
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    val(i: number): number | null {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    levelOrder(): number[] {\n        let res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (let i = 0; i < this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (this.val(i) === null) return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n
    array_binary_tree.dart
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n  late List<int?> _tree;\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  ArrayBinaryTree(this._tree);\n\n  /* \u5217\u8868\u5bb9\u91cf */\n  int size() {\n    return _tree.length;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n  int? val(int i) {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if (i < 0 || i >= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* \u5c42\u5e8f\u904d\u5386 */\n  List<int> levelOrder() {\n    List<int> res = [];\n    for (int i = 0; i < size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n  void dfs(int i, String order, List<int?> res) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if (val(i) == null) {\n      return;\n    }\n    // \u524d\u5e8f\u904d\u5386\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // \u4e2d\u5e8f\u904d\u5386\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // \u540e\u5e8f\u904d\u5386\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* \u524d\u5e8f\u904d\u5386 */\n  List<int?> preOrder() {\n    List<int?> res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* \u4e2d\u5e8f\u904d\u5386 */\n  List<int?> inOrder() {\n    List<int?> res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* \u540e\u5e8f\u904d\u5386 */\n  List<int?> postOrder() {\n    List<int?> res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n
    array_binary_tree.rs
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nstruct ArrayBinaryTree {\n    tree: Vec<Option<i32>>,\n}\n\nimpl ArrayBinaryTree {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(arr: Vec<Option<i32>>) -> Self {\n        Self { tree: arr }\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    fn size(&self) -> i32 {\n        self.tree.len() as i32\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    fn val(&self, i: i32) -> Option<i32> {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de None \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 || i >= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn left(&self, i: i32) -> i32 {\n        2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn right(&self, i: i32) -> i32 {\n        2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn parent(&self, i: i32) -> i32 {\n        (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    fn level_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in 0..self.size() {\n            if let Some(val) = self.val(i) {\n                res.push(val)\n            }\n        }\n        res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    fn dfs(&self, i: i32, order: &str, res: &mut Vec<i32>) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // \u524d\u5e8f\u904d\u5386\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    fn pre_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &mut res);\n        res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    fn in_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &mut res);\n        res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    fn post_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &mut res);\n        res\n    }\n}\n
    array_binary_tree.c
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7ed3\u6784\u4f53 */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt->tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt->tree, arr, sizeof(int) * arrSize);\n    abt->size = arrSize;\n    return abt;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt->tree);\n    free(abt);\n}\n\n/* \u5217\u8868\u5bb9\u91cf */\nint size(ArrayBinaryTree *abt) {\n    return abt->size;\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\nint val(ArrayBinaryTree *abt, int i) {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de INT_MAX \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if (i < 0 || i >= size(abt))\n        return INT_MAX;\n    return abt->tree[i];\n}\n\n/* \u5c42\u5e8f\u904d\u5386 */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if (val(abt, i) == INT_MAX)\n        return;\n    // \u524d\u5e8f\u904d\u5386\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // \u4e2d\u5e8f\u904d\u5386\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // \u540e\u5e8f\u904d\u5386\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* \u524d\u5e8f\u904d\u5386 */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &index);\n    *returnSize = index;\n    return res;\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &index);\n    *returnSize = index;\n    return res;\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &index);\n    *returnSize = index;\n    return res;\n}\n
    array_binary_tree.kt
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree(val tree: List<Int?>) {\n    /* \u5217\u8868\u5bb9\u91cf */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    fun value(i: Int): Int? {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size()) return null\n        return tree[i]\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    fun levelOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (i in 0..<size()) {\n            if (value(i) != null) res.add(value(i))\n        }\n        return res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    fun dfs(i: Int, order: String, res: MutableList<Int?>) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (value(i) == null) return\n        // \u524d\u5e8f\u904d\u5386\n        if (\"pre\" == order) res.add(value(i))\n        dfs(left(i), order, res)\n        // \u4e2d\u5e8f\u904d\u5386\n        if (\"in\" == order) res.add(value(i))\n        dfs(right(i), order, res)\n        // \u540e\u5e8f\u904d\u5386\n        if (\"post\" == order) res.add(value(i))\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    fun preOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    fun inOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    fun postOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n
    array_binary_tree.rb
    [class]{ArrayBinaryTree}-[func]{}\n
    array_binary_tree.zig
    [class]{ArrayBinaryTree}-[func]{}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_tree/array_representation_of_tree/#733-advantages-and-limitations","title":"7.3.3 \u00a0 Advantages and limitations","text":"

    The array representation of binary trees has the following advantages:

    • Arrays are stored in contiguous memory spaces, which is cache-friendly and allows for faster access and traversal.
    • It does not require storing pointers, which saves space.
    • It allows random access to nodes.

    However, the array representation also has some limitations:

    • Array storage requires contiguous memory space, so it is not suitable for storing trees with a large amount of data.
    • Adding or deleting nodes requires array insertion and deletion operations, which are less efficient.
    • When there are many None values in the binary tree, the proportion of node data contained in the array is low, leading to lower space utilization.
    "},{"location":"chapter_tree/avl_tree/","title":"7.5 \u00a0 AVL tree *","text":"

    In the \"Binary Search Tree\" section, we mentioned that after multiple insertions and removals, a binary search tree might degrade to a linked list. In such cases, the time complexity of all operations degrades from \\(O(\\log n)\\) to \\(O(n)\\).

    As shown in the Figure 7-24 , after two node removal operations, this binary search tree will degrade into a linked list.

    Figure 7-24 \u00a0 Degradation of an AVL tree after removing nodes

    For example, in the perfect binary tree shown in the Figure 7-25 , after inserting two nodes, the tree will lean heavily to the left, and the time complexity of search operations will also degrade.

    Figure 7-25 \u00a0 Degradation of an AVL tree after inserting nodes

    In 1962, G. M. Adelson-Velsky and E. M. Landis proposed the \"AVL Tree\" in their paper \"An algorithm for the organization of information\". The paper detailed a series of operations to ensure that after continuously adding and removing nodes, the AVL tree would not degrade, thus maintaining the time complexity of various operations at \\(O(\\log n)\\) level. In other words, in scenarios where frequent additions, removals, searches, and modifications are needed, the AVL tree can always maintain efficient data operation performance, which has great application value.

    "},{"location":"chapter_tree/avl_tree/#751-common-terminology-in-avl-trees","title":"7.5.1 \u00a0 Common terminology in AVL trees","text":"

    An AVL tree is both a binary search tree and a balanced binary tree, satisfying all properties of these two types of binary trees, hence it is a \"balanced binary search tree\".

    "},{"location":"chapter_tree/avl_tree/#1-node-height","title":"1. \u00a0 Node height","text":"

    Since the operations related to AVL trees require obtaining node heights, we need to add a height variable to the node class:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class TreeNode:\n    \"\"\"AVL tree node\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # Node value\n        self.height: int = 0                # Node height\n        self.left: TreeNode | None = None   # Left child reference\n        self.right: TreeNode | None = None  # Right child reference\n
    /* AVL tree node */\nstruct TreeNode {\n    int val{};          // Node value\n    int height = 0;     // Node height\n    TreeNode *left{};   // Left child\n    TreeNode *right{};  // Right child\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n
    /* AVL tree node */\nclass TreeNode {\n    public int val;        // Node value\n    public int height;     // Node height\n    public TreeNode left;  // Left child\n    public TreeNode right; // Right child\n    public TreeNode(int x) { val = x; }\n}\n
    /* AVL tree node */\nclass TreeNode(int? x) {\n    public int? val = x;    // Node value\n    public int height;      // Node height\n    public TreeNode? left;  // Left child reference\n    public TreeNode? right; // Right child reference\n}\n
    /* AVL tree node */\ntype TreeNode struct {\n    Val    int       // Node value\n    Height int       // Node height\n    Left   *TreeNode // Left child reference\n    Right  *TreeNode // Right child reference\n}\n
    /* AVL tree node */\nclass TreeNode {\n    var val: Int // Node value\n    var height: Int // Node height\n    var left: TreeNode? // Left child\n    var right: TreeNode? // Right child\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n
    /* AVL tree node */\nclass TreeNode {\n    val; // Node value\n    height; // Node height\n    left; // Left child pointer\n    right; // Right child pointer\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n
    /* AVL tree node */\nclass TreeNode {\n    val: number;            // Node value\n    height: number;         // Node height\n    left: TreeNode | null;  // Left child pointer\n    right: TreeNode | null; // Right child pointer\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height; \n        this.left = left === undefined ? null : left; \n        this.right = right === undefined ? null : right; \n    }\n}\n
    /* AVL tree node */\nclass TreeNode {\n  int val;         // Node value\n  int height;      // Node height\n  TreeNode? left;  // Left child\n  TreeNode? right; // Right child\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL tree node */\nstruct TreeNode {\n    val: i32,                               // Node value\n    height: i32,                            // Node height\n    left: Option<Rc<RefCell<TreeNode>>>,    // Left child\n    right: Option<Rc<RefCell<TreeNode>>>,   // Right child\n}\n\nimpl TreeNode {\n    /* Constructor */\n    fn new(val: i32) -> Rc<RefCell<Self>> {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n
    /* AVL tree node */\nTreeNode struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* Constructor */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node->val = val;\n    node->height = 0;\n    node->left = NULL;\n    node->right = NULL;\n    return node;\n}\n
    /* AVL tree node */\nclass TreeNode(val _val: Int) {  // Node value\n    val height: Int = 0          // Node height\n    val left: TreeNode? = null   // Left child\n    val right: TreeNode? = null  // Right child\n}\n
    \n
    \n

    The \"node height\" refers to the distance from that node to its farthest leaf node, i.e., the number of \"edges\" passed. It is important to note that the height of a leaf node is \\(0\\), and the height of a null node is \\(-1\\). We will create two utility functions for getting and updating the height of a node:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if node is not None:\n        return node.height\n    return -1\n\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\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\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\n    return node == nullptr ? -1 : node->height;\n}\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\n    node->height = max(height(node->left), height(node->right)) + 1;\n}\n
    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\n    return node == null ? -1 : node.height;\n}\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\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\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\n    return node == null ? -1 : node.height;\n}\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\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\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\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    if lh > rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\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\n    node?.height ?? -1\n}\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\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\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\n    return node === null ? -1 : node.height;\n}\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\n    node.height =\n        Math.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\n    return node === null ? -1 : node.height;\n}\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\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n
    avl_tree.dart
    /* \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\n  return node == null ? -1 : node.height;\n}\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\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n
    avl_tree.rs
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfn height(node: OptionTreeNodeRc) -> i32 {\n    // \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\n    match node {\n        Some(node) => node.borrow().height,\n        None => -1,\n    }\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\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\n    if (node != NULL) {\n        return node->height;\n    }\n    return -1;\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node->left);\n    int rh = height(node->right);\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    if (lh > rh) {\n        node->height = lh + 1;\n    } else {\n        node->height = rh + 1;\n    }\n}\n
    avl_tree.kt
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfun height(node: TreeNode?): Int {\n    // \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\n    return node?.height ?: -1\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfun updateHeight(node: TreeNode?) {\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    node?.height = (max(height(node?.left).toDouble(), height(node?.right).toDouble()) + 1).toInt()\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{height}\n\n[class]{AVLTree}-[func]{update_height}\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\n    return if (node == null) -1 else node.?.height;\n}\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\n    node.?.height = @max(self.height(node.?.left), self.height(node.?.right)) + 1;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2-node-balance-factor","title":"2. \u00a0 Node balance factor","text":"

    The \"balance factor\" of a node is defined as the height of the node's left subtree minus the height of its right subtree, with the balance factor of a null node defined as \\(0\\). We will also encapsulate the functionality of obtaining the node balance factor into a function for easy use later on:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if node is None:\n        return 0\n    # \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return self.height(node.left) - self.height(node.right)\n
    avl_tree.cpp
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode *node) {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == nullptr)\n        return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node->left) - height(node->right);\n}\n
    avl_tree.java
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode node) {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == null)\n        return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return 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\n    if (node == null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return Height(node.left) - Height(node.right);\n}\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\n    if node == nil {\n        return 0\n    }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return t.height(node.Left) - t.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\n    guard let node = node else { return 0 }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node: node.left) - height(node: 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\n    if (node === null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return 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\n    if (node === null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return this.height(node.left) - this.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\n  if (node == null) return 0;\n  // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n  return height(node.left) - height(node.right);\n}\n
    avl_tree.rs
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfn balance_factor(node: OptionTreeNodeRc) -> i32 {\n    match node {\n        // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n        None => 0,\n        // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n        Some(node) => {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\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\n    if (node == NULL) {\n        return 0;\n    }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node->left) - height(node->right);\n}\n
    avl_tree.kt
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfun balanceFactor(node: TreeNode?): Int {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == null) return 0\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node.left) - height(node.right)\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{balance_factor}\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\n    if (node == null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return self.height(node.?.left) - self.height(node.?.right);\n}\n

    Note

    Let the balance factor be \\(f\\), then the balance factor of any node in an AVL tree satisfies \\(-1 \\le f \\le 1\\).

    "},{"location":"chapter_tree/avl_tree/#752-rotations-in-avl-trees","title":"7.5.2 \u00a0 Rotations in AVL trees","text":"

    The characteristic feature of an AVL tree is the \"rotation\" operation, which can restore balance to an unbalanced node without affecting the in-order traversal sequence of the binary tree. In other words, the rotation operation can maintain the property of a \"binary search tree\" while also turning the tree back into a \"balanced binary tree\".

    We call nodes with an absolute balance factor \\(> 1\\) \"unbalanced nodes\". Depending on the type of imbalance, there are four kinds of rotations: right rotation, left rotation, right-left rotation, and left-right rotation. Below, we detail these rotation operations.

    "},{"location":"chapter_tree/avl_tree/#1-right-rotation","title":"1. \u00a0 Right rotation","text":"

    As shown in the Figure 7-26 , the first unbalanced node from the bottom up in the binary tree is \"node 3\". Focusing on the subtree with this unbalanced node as the root, denoted as node, and its left child as child, perform a \"right rotation\". After the right rotation, the subtree is balanced again while still maintaining the properties of a binary search tree.

    <1><2><3><4>

    Figure 7-26 \u00a0 Steps of right rotation

    As shown in the Figure 7-27 , when the child node has a right child (denoted as grand_child), a step needs to be added in the right rotation: set grand_child as the left child of node.

    Figure 7-27 \u00a0 Right rotation with grand_child

    \"Right rotation\" is a figurative term; in practice, it is achieved by modifying node pointers, as shown in the following code:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def right_rotate(self, node: TreeNode | None) -> TreeNode | None:\n    \"\"\"\u53f3\u65cb\u64cd\u4f5c\"\"\"\n    child = node.left\n    grand_child = child.right\n    # \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node\n    node.left = grand_child\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    self.update_height(child)\n    # \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n
    avl_tree.cpp
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node->left;\n    TreeNode *grandChild = child->right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child->right = node;\n    node->left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.java
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.cs
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.go
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.Right = node\n    node.Left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.swift
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc rightRotate(node: TreeNode?) -> TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child?.right = node\n    node?.left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.js
    /* \u53f3\u65cb\u64cd\u4f5c */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.ts
    /* \u53f3\u65cb\u64cd\u4f5c */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.dart
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n  child.right = node;\n  node.left = grandChild;\n  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n  updateHeight(node);\n  updateHeight(child);\n  // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return child;\n}\n
    avl_tree.rs
    /* \u53f3\u65cb\u64cd\u4f5c */\nfn right_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    match node {\n        Some(node) => {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(child)\n        }\n        None => None,\n    }\n}\n
    avl_tree.c
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node->left;\n    grandChild = child->right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child->right = node;\n    node->left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.kt
    /* \u53f3\u65cb\u64cd\u4f5c */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node\n    node.left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node)\n    updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{right_rotate}\n
    avl_tree.zig
    // \u53f3\u65cb\u64cd\u4f5c\nfn rightRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\n    var child = node.?.left;\n    var grandChild = child.?.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.?.right = node;\n    node.?.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.updateHeight(node);\n    self.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2-left-rotation","title":"2. \u00a0 Left rotation","text":"

    Correspondingly, if considering the \"mirror\" of the above unbalanced binary tree, the \"left rotation\" operation shown in the Figure 7-28 needs to be performed.

    Figure 7-28 \u00a0 Left rotation operation

    Similarly, as shown in the Figure 7-29 , when the child node has a left child (denoted as grand_child), a step needs to be added in the left rotation: set grand_child as the right child of node.

    Figure 7-29 \u00a0 Left rotation with grand_child

    It can be observed that the right and left rotation operations are logically symmetrical, and they solve two symmetrical types of imbalance. Based on symmetry, by replacing all left with right, and all right with left in the implementation code of right rotation, we can get the implementation code for left rotation:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def left_rotate(self, node: TreeNode | None) -> TreeNode | None:\n    \"\"\"\u5de6\u65cb\u64cd\u4f5c\"\"\"\n    child = node.right\n    grand_child = child.left\n    # \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node\n    node.right = grand_child\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    self.update_height(child)\n    # \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n
    avl_tree.cpp
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node->right;\n    TreeNode *grandChild = child->left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child->left = node;\n    node->right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.java
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.cs
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.go
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.Left = node\n    node.Right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.swift
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc leftRotate(node: TreeNode?) -> TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child?.left = node\n    node?.right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.js
    /* \u5de6\u65cb\u64cd\u4f5c */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.ts
    /* \u5de6\u65cb\u64cd\u4f5c */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.dart
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n  child.left = node;\n  node.right = grandChild;\n  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n  updateHeight(node);\n  updateHeight(child);\n  // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return child;\n}\n
    avl_tree.rs
    /* \u5de6\u65cb\u64cd\u4f5c */\nfn left_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    match node {\n        Some(node) => {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(child)\n        }\n        None => None,\n    }\n}\n
    avl_tree.c
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node->right;\n    grandChild = child->left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child->left = node;\n    node->right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.kt
    /* \u5de6\u65cb\u64cd\u4f5c */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node\n    node.right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node)\n    updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{left_rotate}\n
    avl_tree.zig
    // \u5de6\u65cb\u64cd\u4f5c\nfn leftRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\n    var child = node.?.right;\n    var grandChild = child.?.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.?.left = node;\n    node.?.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.updateHeight(node);\n    self.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#3-right-left-rotation","title":"3. \u00a0 Right-left rotation","text":"

    For the unbalanced node 3 shown in the Figure 7-30 , using either left or right rotation alone cannot restore balance to the subtree. In this case, a \"left rotation\" needs to be performed on child first, followed by a \"right rotation\" on node.

    Figure 7-30 \u00a0 Right-left rotation

    "},{"location":"chapter_tree/avl_tree/#4-left-right-rotation","title":"4. \u00a0 Left-right rotation","text":"

    As shown in the Figure 7-31 , for the mirror case of the above unbalanced binary tree, a \"right rotation\" needs to be performed on child first, followed by a \"left rotation\" on node.

    Figure 7-31 \u00a0 Left-right rotation

    "},{"location":"chapter_tree/avl_tree/#5-choice-of-rotation","title":"5. \u00a0 Choice of rotation","text":"

    The four kinds of imbalances shown in the Figure 7-32 correspond to the cases described above, respectively requiring right rotation, left-right rotation, right-left rotation, and left rotation.

    Figure 7-32 \u00a0 The four rotation cases of AVL tree

    As shown in the Table 7-3 , we determine which of the above cases an unbalanced node belongs to by judging the sign of the balance factor of the unbalanced node and its higher-side child's balance factor.

    Table 7-3 \u00a0 Conditions for Choosing Among the Four Rotation Cases

    Balance factor of unbalanced node Balance factor of child node Rotation method to use \\(> 1\\) (Left-leaning tree) \\(\\geq 0\\) Right rotation \\(> 1\\) (Left-leaning tree) \\(<0\\) Left rotation then right rotation \\(< -1\\) (Right-leaning tree) \\(\\leq 0\\) Left rotation \\(< -1\\) (Right-leaning tree) \\(>0\\) Right rotation then left rotation

    For convenience, we encapsulate the rotation operations into a function. With this function, we can perform rotations on various kinds of imbalances, restoring balance to unbalanced nodes. The code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    balance_factor = self.balance_factor(node)\n    # \u5de6\u504f\u6811\n    if balance_factor > 1:\n        if self.balance_factor(node.left) >= 0:\n            # \u53f3\u65cb\n            return self.right_rotate(node)\n        else:\n            # \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # \u53f3\u504f\u6811\n    elif balance_factor < -1:\n        if self.balance_factor(node.right) <= 0:\n            # \u5de6\u65cb\n            return self.left_rotate(node)\n        else:\n            # \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node\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\n    int _balanceFactor = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (_balanceFactor > 1) {\n        if (balanceFactor(node->left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node->left = leftRotate(node->left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (_balanceFactor < -1) {\n        if (balanceFactor(node->right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node->right = rightRotate(node->right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\n
    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\n    int balanceFactor = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    int balanceFactorInt = BalanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactorInt > 1) {\n        if (BalanceFactor(node?.left) >= 0) {\n            // \u53f3\u65cb\n            return RightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactorInt < -1) {\n        if (BalanceFactor(node?.right) <= 0) {\n            // \u5de6\u65cb\n            return LeftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\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\n    bf := t.balanceFactor(node)\n    // \u5de6\u504f\u6811\n    if bf > 1 {\n        if t.balanceFactor(node.Left) >= 0 {\n            // \u53f3\u65cb\n            return t.rightRotate(node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if bf < -1 {\n        if t.balanceFactor(node.Right) <= 0 {\n            // \u5de6\u65cb\n            return t.leftRotate(node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    let balanceFactor = balanceFactor(node: node)\n    // \u5de6\u504f\u6811\n    if balanceFactor > 1 {\n        if self.balanceFactor(node: node?.left) >= 0 {\n            // \u53f3\u65cb\n            return rightRotate(node: node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if balanceFactor < -1 {\n        if self.balanceFactor(node: node?.right) <= 0 {\n            // \u5de6\u65cb\n            return leftRotate(node: node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    const balanceFactor = this.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (this.balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return this.#rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (this.balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return this.#leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    const balanceFactor = this.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (this.balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return this.rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (this.balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return this.leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n  int factor = balanceFactor(node);\n  // \u5de6\u504f\u6811\n  if (factor > 1) {\n    if (balanceFactor(node!.left) >= 0) {\n      // \u53f3\u65cb\n      return rightRotate(node);\n    } else {\n      // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // \u53f3\u504f\u6811\n  if (factor < -1) {\n    if (balanceFactor(node!.right) <= 0) {\n      // \u5de6\u65cb\n      return leftRotate(node);\n    } else {\n      // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n  return node;\n}\n
    avl_tree.rs
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfn rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    // \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\n    let balance_factor = Self::balance_factor(node.clone());\n    // \u5de6\u504f\u6811\n    if balance_factor > 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) >= 0 {\n            // \u53f3\u65cb\n            Self::right_rotate(Some(node))\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // \u53f3\u504f\u6811\n    else if balance_factor < -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) <= 0 {\n            // \u5de6\u65cb\n            Self::left_rotate(Some(node))\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n        node\n    }\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\n    int bf = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (bf > 1) {\n        if (balanceFactor(node->left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node->left = leftRotate(node->left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (bf < -1) {\n        if (balanceFactor(node->right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node->right = rightRotate(node->right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\n
    avl_tree.kt
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfun rotate(node: TreeNode): TreeNode {\n    // \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\n    val balanceFactor = balanceFactor(node)\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{rotate}\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\n    var balance_factor = self.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balance_factor > 1) {\n        if (self.balanceFactor(node.?.left) >= 0) {\n            // \u53f3\u65cb\n            return self.rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.?.left = self.leftRotate(node.?.left);\n            return self.rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balance_factor < -1) {\n        if (self.balanceFactor(node.?.right) <= 0) {\n            // \u5de6\u65cb\n            return self.leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.?.right = self.rightRotate(node.?.right);\n            return self.leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#753-common-operations-in-avl-trees","title":"7.5.3 \u00a0 Common operations in AVL trees","text":""},{"location":"chapter_tree/avl_tree/#1-node-insertion","title":"1. \u00a0 Node insertion","text":"

    The node insertion operation in AVL trees is similar to that in binary search trees. The only difference is that after inserting a node in an AVL tree, a series of unbalanced nodes may appear along the path from that node to the root node. Therefore, we need to start from this node and perform rotation operations upwards to restore balance to all unbalanced nodes. The code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def insert(self, val):\n    \"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:\n    \"\"\"\u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9\n    if val < node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val > node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    # 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\n    return self.rotate(node)\n
    avl_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node->val)\n        node->left = insertHelper(node->left, val);\n    else if (val > node->val)\n        node->right = insertHelper(node->right, val);\n    else\n        return node;    // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = Rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if val < node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val > node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = t.rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc insertHelper(node: TreeNode?, val: Int) -> TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if val < node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val > node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    updateHeight(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 */\n    node = rotate(node: node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    this.#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 */\n    node = this.#rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val > node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    this.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 */\n    node = this.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.dart
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n  if (val < node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val > node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n  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 */\n  node = rotate(node);\n  // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return node;\n}\n
    avl_tree.rs
    /* \u63d2\u5165\u8282\u70b9 */\nfn insert(&mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {\n    match node {\n        Some(mut node) => {\n            /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&val)\n            {\n                Ordering::Greater => {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less => {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal => {\n                    return Some(node); // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n                }\n            }\n            Self::update_height(Some(node.clone())); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n\n            /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n            node = Self::rotate(Some(node)).unwrap();\n            // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(node)\n        }\n        None => Some(TreeNode::new(val)),\n    }\n}\n
    avl_tree.c
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(AVLTree *tree, int val) {\n    tree->root = insertHelper(tree->root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node->val) {\n        node->left = insertHelper(node->left, val);\n    } else if (val > node->val) {\n        node->right = insertHelper(node->right, val);\n    } else {\n        // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node;\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.kt
    /* \u63d2\u5165\u8282\u70b9 */\nfun insert(value: Int) {\n    root = insertHelper(root, value)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfun insertHelper(n: TreeNode?, value: Int): TreeNode {\n    if (n == null)\n        return TreeNode(value)\n    var node = n\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (value < node.value) node.left = insertHelper(node.left, value)\n    else if (value > node.value) node.right = insertHelper(node.right, value)\n    else return node // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n\n    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 */\n    node = rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{insert}\n\n[class]{AVLTree}-[func]{insert_helper}\n
    avl_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, val: T) !void {\n    self.root = (try self.insertHelper(self.root, val)).?;\n}\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) {\n    var node = node_;\n    if (node == null) {\n        var tmp_node = try self.mem_allocator.create(inc.TreeNode(T));\n        tmp_node.init(val);\n        return tmp_node;\n    }\n    // 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9\n    if (val < node.?.val) {\n        node.?.left = try self.insertHelper(node.?.left, val);\n    } else if (val > node.?.val) {\n        node.?.right = try self.insertHelper(node.?.right, val);\n    } else {\n        return node;            // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    self.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\n    node = self.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2-node-removal","title":"2. \u00a0 Node removal","text":"

    Similarly, based on the method of removing nodes in binary search trees, rotation operations need to be performed from the bottom up to restore balance to all unbalanced nodes. The code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def remove(self, val: int):\n    \"\"\"\u5220\u9664\u8282\u70b9\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:\n    \"\"\"\u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\n    if node is None:\n        return None\n    # 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664\n    if val < node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val > node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if child is None:\n                return None\n            # \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else:\n                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\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    # 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\n    return self.rotate(node)\n
    avl_tree.cpp
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node->val)\n        node->left = removeHelper(node->left, val);\n    else if (val > node->val)\n        node->right = removeHelper(node->right, val);\n    else {\n        if (node->left == nullptr || node->right == nullptr) {\n            TreeNode *child = node->left != nullptr ? node->left : node->right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else {\n                delete node;\n                node = 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\n            TreeNode *temp = node->right;\n            while (temp->left != nullptr) {\n                temp = temp->left;\n            }\n            int tempVal = temp->val;\n            node->right = removeHelper(node->right, temp->val);\n            node->val = tempVal;\n        }\n    }\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val > node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == null)\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else\n                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\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.cs
    /* \u5220\u9664\u8282\u70b9 */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val > node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == null)\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else\n                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\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    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 */\n    node = Rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if val < node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val > node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n                return nil\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = t.rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc removeHelper(node: TreeNode?, val: Int) -> TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if val < node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val > node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if child == nil {\n                return nil\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else {\n                node = 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\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(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 */\n    node = rotate(node: node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val > node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child === null) return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else 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\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#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 */\n    node = this.#rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val > node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child === null) {\n                return null;\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.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 */\n    node = this.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.dart
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n  if (val < node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val > node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n      if (child == null)\n        return null;\n      // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n      else\n        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\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  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 */\n  node = rotate(node);\n  // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return node;\n}\n
    avl_tree.rs
    /* \u5220\u9664\u8282\u70b9 */\nfn remove(&self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {\n    match node {\n        Some(mut node) => {\n            /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n            if val < node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val > node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n                    None => {\n                        return None;\n                    }\n                    // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                    Some(child) => node = 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\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n\n            /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n            node = Self::rotate(Some(node)).unwrap();\n            // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(node)\n        }\n        None => None,\n    }\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 removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree->root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node->val) {\n        node->left = removeHelper(node->left, val);\n    } else if (val > node->val) {\n        node->right = removeHelper(node->right, val);\n    } else {\n        if (node->left == NULL || node->right == NULL) {\n            child = node->left;\n            if (node->right != NULL) {\n                child = node->right;\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            TreeNode *temp = node->right;\n            while (temp->left != NULL) {\n                temp = temp->left;\n            }\n            int tempVal = temp->val;\n            node->right = removeHelper(node->right, temp->val);\n            node->val = tempVal;\n        }\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.kt
    /* \u5220\u9664\u8282\u70b9 */\nfun remove(value: Int) {\n    root = removeHelper(root, value)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfun removeHelper(n: TreeNode?, value: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (value < node.value) node.left = removeHelper(node.left, value)\n    else if (value > node.value) node.right = removeHelper(node.right, value)\n    else {\n        if (node.left == null || node.right == null) {\n            val 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\n            if (child == null) return null\n            else 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\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp.value)\n            node.value = temp.value\n        }\n    }\n    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 */\n    node = rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{remove}\n\n[class]{AVLTree}-[func]{remove_helper}\n
    avl_tree.zig
    // \u5220\u9664\u8282\u70b9\nfn remove(self: *Self, val: T) void {\n   self.root = self.removeHelper(self.root, val).?;\n}\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) {\n    var node = node_;\n    if (node == null) return null;\n    // 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664\n    if (val < node.?.val) {\n        node.?.left = self.removeHelper(node.?.left, val);\n    } else if (val > node.?.val) {\n        node.?.right = self.removeHelper(node.?.right, val);\n    } else {\n        if (node.?.left == null or node.?.right == null) {\n            var 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\n            if (child == null) {\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            } else {\n                node = 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\n            var temp = node.?.right;\n            while (temp.?.left != null) {\n                temp = temp.?.left;\n            }\n            node.?.right = self.removeHelper(node.?.right, temp.?.val);\n            node.?.val = temp.?.val;\n        }\n    }\n    self.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\n    node = self.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#3-node-search","title":"3. \u00a0 Node search","text":"

    The node search operation in AVL trees is consistent with that in binary search trees and will not be detailed here.

    "},{"location":"chapter_tree/avl_tree/#754-typical-applications-of-avl-trees","title":"7.5.4 \u00a0 Typical applications of AVL trees","text":"
    • Organizing and storing large amounts of data, suitable for scenarios with high-frequency searches and low-frequency intertions and removals.
    • Used to build index systems in databases.
    • Red-black trees are also a common type of balanced binary search tree. Compared to AVL trees, red-black trees have more relaxed balancing conditions, require fewer rotations for node insertion and removal, and have a higher average efficiency for node addition and removal operations.
    "},{"location":"chapter_tree/binary_search_tree/","title":"7.4 \u00a0 Binary search tree","text":"

    As shown in the Figure 7-16 , a \"binary search tree\" satisfies the following conditions.

    1. For the root node, the value of all nodes in the left subtree < the value of the root node < the value of all nodes in the right subtree.
    2. The left and right subtrees of any node are also binary search trees, i.e., they satisfy condition 1. as well.

    Figure 7-16 \u00a0 Binary search tree

    "},{"location":"chapter_tree/binary_search_tree/#741-operations-on-a-binary-search-tree","title":"7.4.1 \u00a0 Operations on a binary search tree","text":"

    We encapsulate the binary search tree as a class BinarySearchTree and declare a member variable root, pointing to the tree's root node.

    "},{"location":"chapter_tree/binary_search_tree/#1-searching-for-a-node","title":"1. \u00a0 Searching for a node","text":"

    Given a target node value num, one can search according to the properties of the binary search tree. As shown in the Figure 7-17 , we declare a node cur and start from the binary tree's root node root, looping to compare the size relationship between the node value cur.val and num.

    • If cur.val < num, it means the target node is in cur's right subtree, thus execute cur = cur.right.
    • If cur.val > num, it means the target node is in cur's left subtree, thus execute cur = cur.left.
    • If cur.val = num, it means the target node is found, exit the loop and return the node.
    <1><2><3><4>

    Figure 7-17 \u00a0 Example of searching for a node in a binary search tree

    The search operation in a binary search tree works on the same principle as the binary search algorithm, eliminating half of the possibilities in each round. The number of loops is at most the height of the binary tree. When the binary tree is balanced, it uses \\(O(\\log n)\\) time. Example code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def search(self, num: int) -> TreeNode | None:\n    \"\"\"\u67e5\u627e\u8282\u70b9\"\"\"\n    cur = self._root\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur is not None:\n        # \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        elif cur.val > num:\n            cur = cur.left\n        # \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else:\n            break\n    return cur\n
    binary_search_tree.cpp
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur->val > num)\n            cur = cur->left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.java
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num)\n            cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.cs
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur =\n            cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num)\n            cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.go
    /* \u67e5\u627e\u8282\u70b9 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for node != nil {\n        if node.Val.(int) < num {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            node = node.Right\n        } else if node.Val.(int) > num {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            node = node.Left\n        } else {\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return node\n}\n
    binary_search_tree.swift
    /* \u67e5\u627e\u8282\u70b9 */\nfunc search(num: Int) -> TreeNode? {\n    var cur = root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if cur!.val > num {\n            cur = cur?.left\n        }\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else {\n            break\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur\n}\n
    binary_search_tree.js
    /* \u67e5\u627e\u8282\u70b9 */\nsearch(num) {\n    let cur = this.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num) cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.ts
    /* \u67e5\u627e\u8282\u70b9 */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num) cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.dart
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else if (cur.val > _num)\n      cur = cur.left;\n    // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n    else\n      break;\n  }\n  // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n  return cur;\n}\n
    binary_search_tree.rs
    /* \u67e5\u627e\u8282\u70b9 */\npub fn search(&self, num: i32) -> OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => cur = node.borrow().right.clone(),\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => cur = node.borrow().left.clone(),\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            Ordering::Equal => break,\n        }\n    }\n\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    cur\n}\n
    binary_search_tree.c
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst->root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        if (cur->val < num) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else if (cur->val > num) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.kt
    /* \u67e5\u627e\u8282\u70b9 */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.value > num) cur.left\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{search}\n
    binary_search_tree.zig
    // \u67e5\u627e\u8282\u70b9\nfn search(self: *Self, num: T) ?*inc.TreeNode(T) {\n    var cur = self.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else if (cur.?.val > num) {\n            cur = cur.?.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        } else {\n            break;\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_tree/binary_search_tree/#2-inserting-a-node","title":"2. \u00a0 Inserting a node","text":"

    Given an element num to be inserted, to maintain the property of the binary search tree \"left subtree < root node < right subtree,\" the insertion operation proceeds as shown in the Figure 7-18 .

    1. Finding the insertion position: Similar to the search operation, start from the root node and loop downwards according to the size relationship between the current node value and num until passing through the leaf node (traversing to None) then exit the loop.
    2. Insert the node at that position: Initialize the node num and place it where None was.

    Figure 7-18 \u00a0 Inserting a node into a binary search tree

    In the code implementation, note the following two points.

    • The binary search tree does not allow duplicate nodes; otherwise, it will violate its definition. Therefore, if the node to be inserted already exists in the tree, the insertion is not performed, and it directly returns.
    • To perform the insertion operation, we need to use the node pre to save the node from the last loop. This way, when traversing to None, we can get its parent node, thus completing the node insertion operation.
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def insert(self, num: int):\n    \"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\n    # \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    cur, pre = self._root, None\n    while cur is not None:\n        # \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if cur.val == num:\n            return\n        pre = cur\n        # \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else:\n            cur = cur.left\n    # \u63d2\u5165\u8282\u70b9\n    node = TreeNode(num)\n    if pre.val < num:\n        pre.right = node\n    else:\n        pre.left = node\n
    binary_search_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur->val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur->left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode *node = new TreeNode(num);\n    if (pre->val < num)\n        pre->right = node;\n    else\n        pre->left = node;\n}\n
    binary_search_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode node = new TreeNode(num);\n    if (pre.val < num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n
    binary_search_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid Insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val < num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n
    binary_search_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // \u5f85\u63d2\u5165\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\n    var pre *TreeNode = nil\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) < num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    node := NewTreeNode(num)\n    if pre.Val.(int) < num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n
    binary_search_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\nfunc insert(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else {\n            cur = cur?.left\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    let node = TreeNode(x: num)\n    if pre!.val < num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n
    binary_search_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val === num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    const node = new TreeNode(num);\n    if (pre.val < num) pre.right = node;\n    else pre.left = node;\n}\n
    binary_search_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(num: number): void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val === num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    const node = new TreeNode(num);\n    if (pre!.val < num) pre!.right = node;\n    else pre!.left = node;\n}\n
    binary_search_tree.dart
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int _num) {\n  // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n    if (cur.val == _num) return;\n    pre = cur;\n    // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else\n      cur = cur.left;\n  }\n  // \u63d2\u5165\u8282\u70b9\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val < _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n
    binary_search_tree.rs
    /* \u63d2\u5165\u8282\u70b9 */\npub fn insert(&mut self, num: i32) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n            Ordering::Equal => return,\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num > pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().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\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (bst->root == NULL) {\n        bst->root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst->root, *pre = NULL;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur->val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur->val < num) {\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else {\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode *node = newTreeNode(num);\n    if (pre->val < num) {\n        pre->right = node;\n    } else {\n        pre->left = node;\n    }\n}\n
    binary_search_tree.kt
    /* \u63d2\u5165\u8282\u70b9 */\nfun insert(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.value == num) return\n        pre = cur\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur.left\n    }\n    // \u63d2\u5165\u8282\u70b9\n    val node = TreeNode(num)\n    if (pre?.value!! < num) pre.right = node\n    else pre.left = node\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{insert}\n
    binary_search_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, num: T) !void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (self.root == null) {\n        self.root = try self.mem_allocator.create(inc.TreeNode(T));\n        return;\n    }\n    var cur = self.root;\n    var pre: ?*inc.TreeNode(T) = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.?.val == num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else {\n            cur = cur.?.left;\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    var node = try self.mem_allocator.create(inc.TreeNode(T));\n    node.init(num);\n    if (pre.?.val < num) {\n        pre.?.right = node;\n    } else {\n        pre.?.left = node;\n    }\n}\n
    Code Visualization

    Full Screen >

    Similar to searching for a node, inserting a node uses \\(O(\\log n)\\) time.

    "},{"location":"chapter_tree/binary_search_tree/#3-removing-a-node","title":"3. \u00a0 Removing a node","text":"

    First, find the target node in the binary tree, then remove it. Similar to inserting a node, we need to ensure that after the removal operation is completed, the property of the binary search tree \"left subtree < root node < right subtree\" is still satisfied. Therefore, based on the number of child nodes of the target node, we divide it into 0, 1, and 2 cases, performing the corresponding node removal operations.

    As shown in the Figure 7-19 , when the degree of the node to be removed is \\(0\\), it means the node is a leaf node, and it can be directly removed.

    Figure 7-19 \u00a0 Removing a node in a binary search tree (degree 0)

    As shown in the Figure 7-20 , when the degree of the node to be removed is \\(1\\), replacing the node to be removed with its child node is sufficient.

    Figure 7-20 \u00a0 Removing a node in a binary search tree (degree 1)

    When the degree of the node to be removed is \\(2\\), we cannot remove it directly, but need to use a node to replace it. To maintain the property of the binary search tree \"left subtree < root node < right subtree,\" this node can be either the smallest node of the right subtree or the largest node of the left subtree.

    Assuming we choose the smallest node of the right subtree (the next node in in-order traversal), then the removal operation proceeds as shown in the Figure 7-21 .

    1. Find the next node in the \"in-order traversal sequence\" of the node to be removed, denoted as tmp.
    2. Replace the value of the node to be removed with tmp's value, and recursively remove the node tmp in the tree.
    <1><2><3><4>

    Figure 7-21 \u00a0 Removing a node in a binary search tree (degree 2)

    The operation of removing a node also uses \\(O(\\log n)\\) time, where finding the node to be removed requires \\(O(\\log n)\\) time, and obtaining the in-order traversal successor node requires \\(O(\\log n)\\) time. Example code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def remove(self, num: int):\n    \"\"\"\u5220\u9664\u8282\u70b9\"\"\"\n    # \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if self._root is None:\n        return\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    cur, pre = self._root, None\n    while cur is not None:\n        # \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if cur.val == num:\n            break\n        pre = cur\n        # \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else:\n            cur = cur.left\n    # \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur is None:\n        return\n\n    # \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if 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\n        child = cur.left or cur.right\n        # \u5220\u9664\u8282\u70b9 cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            self._root = child\n    # \u5b50\u8282\u70b9\u6570\u91cf = 2\n    else:\n        # \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        self.remove(tmp.val)\n        # \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val\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\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur->val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur->left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == nullptr)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur->left == nullptr || cur->right == nullptr) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\n        TreeNode *child = cur->left != nullptr ? cur->left : cur->right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre->left == cur)\n                pre->left = child;\n            else\n                pre->right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\n        // \u91ca\u653e\u5185\u5b58\n        delete cur;\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\n        TreeNode *tmp = cur->right;\n        while (tmp->left != nullptr) {\n            tmp = tmp->left;\n        }\n        int tmpVal = tmp->val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp->val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur->val = tmpVal;\n    }\n}\n
    binary_search_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\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\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\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\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        TreeNode? child = cur.left ?? cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\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\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        Remove(tmp.val!.Value);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\n    }\n}\n
    binary_search_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5f85\u5220\u9664\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\n    var pre *TreeNode = nil\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) < num {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728\u53f3\u5b50\u6811\u4e2d\n            cur = cur.Right\n        } else {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728\u5de6\u5b50\u6811\u4e2d\n            cur = cur.Left\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5b50\u8282\u70b9\u6570\u4e3a 0 \u6216 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // \u53d6\u51fa\u5f85\u5220\u9664\u8282\u70b9\u7684\u5b50\u8282\u70b9\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // \u5220\u9664\u8282\u70b9 cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            bst.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\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        bst.remove(tmp.Val.(int))\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.Val = tmp.Val\n    }\n}\n
    binary_search_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\nfunc remove(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else {\n            cur = cur?.left\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        let child = cur?.left ?? cur?.right\n        // \u5220\u9664\u8282\u70b9 cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child\n        }\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\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(num: tmp!.val)\n        // \u7528 tmp \u8986\u76d6 cur\n        cur?.val = tmp!.val\n    }\n}\n
    binary_search_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nremove(num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val === num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur === null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        const child = cur.left !== null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            this.root = child;\n        }\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\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        this.remove(tmp.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\n    }\n}\n
    binary_search_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nremove(num: number): void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val === num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur === null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            this.root = child;\n        }\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\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        this.remove(tmp!.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp!.val;\n    }\n}\n
    binary_search_tree.dart
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int _num) {\n  // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n    if (cur.val == _num) break;\n    pre = cur;\n    // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else\n      cur = cur.left;\n  }\n  // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n  if (cur == null) return;\n  // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n    TreeNode? child = cur.left ?? cur.right;\n    // \u5220\u9664\u8282\u70b9 cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n      _root = 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\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n    remove(tmp.val);\n    // \u7528 tmp \u8986\u76d6 cur\n    cur.val = tmp.val;\n  }\n}\n
    binary_search_tree.rs
    /* \u5220\u9664\u8282\u70b9 */\npub fn remove(&mut self, num: i32) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            Ordering::Equal => break,\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) => {\n            // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // \u5220\u9664\u8282\u70b9 cur\n            if !Rc::ptr_eq(&cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() && Rc::ptr_eq(&left.as_ref().unwrap(), &cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n                self.root = child;\n            }\n        }\n        // \u5b50\u8282\u70b9\u6570\u91cf = 2\n        (Some(_), Some(_)) => {\n            // \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmpval = tmp.unwrap().borrow().val;\n            // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n            self.remove(tmpval);\n            // \u7528 tmp \u8986\u76d6 cur\n            cur.borrow_mut().val = tmpval;\n        }\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 removeItem(BinarySearchTree *bst, int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (bst->root == NULL)\n        return;\n    TreeNode *cur = bst->root, *pre = NULL;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur->val == num)\n            break;\n        pre = cur;\n        if (cur->val < num) {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == NULL)\n        return;\n    // \u5224\u65ad\u5f85\u5220\u9664\u8282\u70b9\u662f\u5426\u5b58\u5728\u5b50\u8282\u70b9\n    if (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\n        TreeNode *child = cur->left != NULL ? cur->left : cur->right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (pre->left == cur) {\n            pre->left = child;\n        } else {\n            pre->right = child;\n        }\n        // \u91ca\u653e\u5185\u5b58\n        free(cur);\n    } else {\n        /* \u5b50\u8282\u70b9\u6570\u91cf = 2 */\n        // \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n        TreeNode *tmp = cur->right;\n        while (tmp->left != NULL) {\n            tmp = tmp->left;\n        }\n        int tmpVal = tmp->val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        removeItem(bst, tmp->val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur->val = tmpVal;\n    }\n}\n
    binary_search_tree.kt
    /* \u5220\u9664\u8282\u70b9 */\nfun remove(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (root == null) return\n    var cur = root\n    var pre: TreeNode? = null\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.value == num) break\n        pre = cur\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur.left\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null) return\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        val child = if (cur.left != null) cur.left else cur.right\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre!!.left == cur) pre.left = child\n            else pre.right = child\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = 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\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp.value)\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.value = tmp.value\n    }\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{remove}\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\n    if (self.root == null) return;\n    var cur = self.root;\n    var pre: ?*inc.TreeNode(T) = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.?.val == num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else {\n            cur = cur.?.left;\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.?.left == null or cur.?.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        var child = if (cur.?.left != null) cur.?.left else cur.?.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (pre.?.left == cur) {\n            pre.?.left = child;\n        } else {\n            pre.?.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\n        var tmp = cur.?.right;\n        while (tmp.?.left != null) {\n            tmp = tmp.?.left;\n        }\n        var tmp_val = tmp.?.val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        self.remove(tmp.?.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.?.val = tmp_val;\n    }\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_tree/binary_search_tree/#4-in-order-traversal-is-ordered","title":"4. \u00a0 In-order traversal is ordered","text":"

    As shown in the Figure 7-22 , the in-order traversal of a binary tree follows the \"left \\(\\rightarrow\\) root \\(\\rightarrow\\) right\" traversal order, and a binary search tree satisfies the size relationship \"left child node < root node < right child node\".

    This means that in-order traversal in a binary search tree always traverses the next smallest node first, thus deriving an important property: The in-order traversal sequence of a binary search tree is ascending.

    Using the ascending property of in-order traversal, obtaining ordered data in a binary search tree requires only \\(O(n)\\) time, without the need for additional sorting operations, which is very efficient.

    Figure 7-22 \u00a0 In-order traversal sequence of a binary search tree

    "},{"location":"chapter_tree/binary_search_tree/#742-efficiency-of-binary-search-trees","title":"7.4.2 \u00a0 Efficiency of binary search trees","text":"

    Given a set of data, we consider using an array or a binary search tree for storage. Observing the Table 7-2 , the operations on a binary search tree all have logarithmic time complexity, which is stable and efficient. Only in scenarios of high-frequency addition and low-frequency search and removal, arrays are more efficient than binary search trees.

    Table 7-2 \u00a0 Efficiency comparison between arrays and search trees

    Unsorted array Binary search tree Search element \\(O(n)\\) \\(O(\\log n)\\) Insert element \\(O(1)\\) \\(O(\\log n)\\) Remove element \\(O(n)\\) \\(O(\\log n)\\)

    In ideal conditions, the binary search tree is \"balanced,\" thus any node can be found within \\(\\log n\\) loops.

    However, continuously inserting and removing nodes in a binary search tree may lead to the binary tree degenerating into a chain list as shown in the Figure 7-23 , at which point the time complexity of various operations also degrades to \\(O(n)\\).

    Figure 7-23 \u00a0 Degradation of a binary search tree

    "},{"location":"chapter_tree/binary_search_tree/#743-common-applications-of-binary-search-trees","title":"7.4.3 \u00a0 Common applications of binary search trees","text":"
    • Used as multi-level indexes in systems to implement efficient search, insertion, and removal operations.
    • Serves as the underlying data structure for certain search algorithms.
    • Used to store data streams to maintain their ordered state.
    "},{"location":"chapter_tree/binary_tree/","title":"7.1 \u00a0 Binary tree","text":"

    A \"binary tree\" is a non-linear data structure that represents the ancestral and descendent relationships, embodying the \"divide and conquer\" logic. Similar to a linked list, the basic unit of a binary tree is a node, each containing a value, a reference to the left child node, and a reference to the right child node.

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class TreeNode:\n    \"\"\"Binary tree node\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # Node value\n        self.left: TreeNode | None = None  # Reference to left child node\n        self.right: TreeNode | None = None # Reference to right child node\n
    /* Binary tree node */\nstruct TreeNode {\n    int val;          // Node value\n    TreeNode *left;   // Pointer to left child node\n    TreeNode *right;  // Pointer to right child node\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n
    /* Binary tree node */\nclass TreeNode {\n    int val;         // Node value\n    TreeNode left;   // Reference to left child node\n    TreeNode right;  // Reference to right child node\n    TreeNode(int x) { val = x; }\n}\n
    /* Binary tree node */\nclass TreeNode(int? x) {\n    public int? val = x;    // Node value\n    public TreeNode? left;  // Reference to left child node\n    public TreeNode? right; // Reference to right child node\n}\n
    /* Binary tree node */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc NewTreeNode(v int) *TreeNode {\n    return &TreeNode{\n        Left:  nil, // Pointer to left child node\n        Right: nil, // Pointer to right child node\n        Val:   v,   // Node value\n    }\n}\n
    /* Binary tree node */\nclass TreeNode {\n    var val: Int // Node value\n    var left: TreeNode? // Reference to left child node\n    var right: TreeNode? // Reference to right child node\n\n    init(x: Int) {\n        val = x\n    }\n}\n
    /* Binary tree node */\nclass TreeNode {\n    val; // Node value\n    left; // Pointer to left child node\n    right; // Pointer to right child node\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n
    /* Binary tree node */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // Node value\n        this.left = left === undefined ? null : left; // Reference to left child node\n        this.right = right === undefined ? null : right; // Reference to right child node\n    }\n}\n
    /* Binary tree node */\nclass TreeNode {\n  int val;         // Node value\n  TreeNode? left;  // Reference to left child node\n  TreeNode? right; // Reference to right child node\n  TreeNode(this.val, [this.left, this.right]);\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* Binary tree node */\nstruct TreeNode {\n    val: i32,                               // Node value\n    left: Option<Rc<RefCell<TreeNode>>>,    // Reference to left child node\n    right: Option<Rc<RefCell<TreeNode>>>,   // Reference to right child node\n}\n\nimpl TreeNode {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(val: i32) -> Rc<RefCell<Self>> {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n
    /* Binary tree node */\ntypedef struct TreeNode {\n    int val;                // Node value\n    int height;             // \u8282\u70b9\u9ad8\u5ea6\n    struct TreeNode *left;  // Pointer to left child node\n    struct TreeNode *right; // Pointer to right child node\n} TreeNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node->val = val;\n    node->height = 0;\n    node->left = NULL;\n    node->right = NULL;\n    return node;\n}\n
    /* Binary tree node */\nclass TreeNode(val _val: Int) {  // Node value\n    val left: TreeNode? = null   // Reference to left child node\n    val right: TreeNode? = null  // Reference to right child node\n}\n
    \n
    \n

    Each node has two references (pointers), pointing to the \"left-child node\" and \"right-child node,\" respectively. This node is called the \"parent node\" of these two child nodes. When given a node of a binary tree, we call the tree formed by this node's left child and all nodes under it the \"left subtree\" of this node. Similarly, the \"right subtree\" can be defined.

    In a binary tree, except for leaf nodes, all other nodes contain child nodes and non-empty subtrees. As shown in the Figure 7-1 , if \"Node 2\" is considered as the parent node, then its left and right child nodes are \"Node 4\" and \"Node 5,\" respectively. The left subtree is \"the tree formed by Node 4 and all nodes under it,\" and the right subtree is \"the tree formed by Node 5 and all nodes under it.\"

    Figure 7-1 \u00a0 Parent Node, child Node, subtree

    "},{"location":"chapter_tree/binary_tree/#711-common-terminology-of-binary-trees","title":"7.1.1 \u00a0 Common terminology of binary trees","text":"

    The commonly used terminology of binary trees is shown in the following figure.

    • \"Root node\": The node at the top level of the binary tree, which has no parent node.
    • \"Leaf node\": A node with no children, both of its pointers point to None.
    • \"Edge\": The line segment connecting two nodes, i.e., node reference (pointer).
    • The \"level\" of a node: Incrementing from top to bottom, with the root node's level being 1.
    • The \"degree\" of a node: The number of a node's children. In a binary tree, the degree can be 0, 1, or 2.
    • The \"height\" of a binary tree: The number of edges passed from the root node to the farthest leaf node.
    • The \"depth\" of a node: The number of edges passed from the root node to the node.
    • The \"height\" of a node: The number of edges from the farthest leaf node to the node.

    Figure 7-2 \u00a0 Common Terminology of Binary Trees

    Tip

    Please note that we usually define \"height\" and \"depth\" as \"the number of edges passed,\" but some problems or textbooks may define them as \"the number of nodes passed.\" In this case, both height and depth need to be incremented by 1.

    "},{"location":"chapter_tree/binary_tree/#712-basic-operations-of-binary-trees","title":"7.1.2 \u00a0 Basic operations of binary trees","text":""},{"location":"chapter_tree/binary_tree/#1-initializing-a-binary-tree","title":"1. \u00a0 Initializing a binary tree","text":"

    Similar to a linked list, initialize nodes first, then construct references (pointers).

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_tree.py
    # Initializing a binary tree\n# Initializing nodes\nn1 = TreeNode(val=1)\nn2 = TreeNode(val=2)\nn3 = TreeNode(val=3)\nn4 = TreeNode(val=4)\nn5 = TreeNode(val=5)\n# Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.cpp
    /* Initializing a binary tree */\n// Initializing nodes\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// Linking references (pointers) between nodes\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    binary_tree.java
    // Initializing nodes\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// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.cs
    /* Initializing a binary tree */\n// Initializing nodes\nTreeNode n1 = new(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.go
    /* Initializing a binary tree */\n// Initializing nodes\nn1 := NewTreeNode(1)\nn2 := NewTreeNode(2)\nn3 := NewTreeNode(3)\nn4 := NewTreeNode(4)\nn5 := NewTreeNode(5)\n// Linking references (pointers) between nodes\nn1.Left = n2\nn1.Right = n3\nn2.Left = n4\nn2.Right = n5\n
    binary_tree.swift
    // Initializing nodes\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// Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.js
    /* Initializing a binary tree */\n// Initializing nodes\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.ts
    /* Initializing a binary tree */\n// Initializing nodes\nlet n1 = new TreeNode(1),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.dart
    /* Initializing a binary tree */\n// Initializing nodes\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// Linking references (pointers) between nodes\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.rs
    // Initializing nodes\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// Linking references (pointers) between nodes\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(n5);\n
    binary_tree.c
    /* Initializing a binary tree */\n// Initializing nodes\nTreeNode *n1 = newTreeNode(1);\nTreeNode *n2 = newTreeNode(2);\nTreeNode *n3 = newTreeNode(3);\nTreeNode *n4 = newTreeNode(4);\nTreeNode *n5 = newTreeNode(5);\n// Linking references (pointers) between nodes\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    binary_tree.kt
    // Initializing nodes\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// Linking references (pointers) between nodes\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.rb
    \n
    binary_tree.zig
    \n
    Code visualization

    https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false

    "},{"location":"chapter_tree/binary_tree/#2-inserting-and-removing-nodes","title":"2. \u00a0 Inserting and removing nodes","text":"

    Similar to a linked list, inserting and removing nodes in a binary tree can be achieved by modifying pointers. The Figure 7-3 provides an example.

    Figure 7-3 \u00a0 Inserting and removing nodes in a binary tree

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_tree.py
    # Inserting and removing nodes\np = TreeNode(0)\n# Inserting node P between n1 -> n2\nn1.left = p\np.left = n2\n# Removing node P\nn1.left = n2\n
    binary_tree.cpp
    /* Inserting and removing nodes */\nTreeNode* P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1->left = P;\nP->left = n2;\n// Removing node P\nn1->left = n2;\n
    binary_tree.java
    TreeNode P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n
    binary_tree.cs
    /* Inserting and removing nodes */\nTreeNode P = new(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n
    binary_tree.go
    /* Inserting and removing nodes */\n// Inserting node P between n1 and n2\np := NewTreeNode(0)\nn1.Left = p\np.Left = n2\n// Removing node P\nn1.Left = n2\n
    binary_tree.swift
    let P = TreeNode(x: 0)\n// Inserting node P between n1 and n2\nn1.left = P\nP.left = n2\n// Removing node P\nn1.left = n2\n
    binary_tree.js
    /* Inserting and removing nodes */\nlet P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n
    binary_tree.ts
    /* Inserting and removing nodes */\nconst P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n
    binary_tree.dart
    /* Inserting and removing nodes */\nTreeNode P = new TreeNode(0);\n// Inserting node P between n1 and n2\nn1.left = P;\nP.left = n2;\n// Removing node P\nn1.left = n2;\n
    binary_tree.rs
    let p = TreeNode::new(0);\n// Inserting node P between n1 and n2\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// Removing node P\nn1.borrow_mut().left = Some(n2);\n
    binary_tree.c
    /* Inserting and removing nodes */\nTreeNode *P = newTreeNode(0);\n// Inserting node P between n1 and n2\nn1->left = P;\nP->left = n2;\n// Removing node P\nn1->left = n2;\n
    binary_tree.kt
    val P = TreeNode(0)\n// Inserting node P between n1 and n2\nn1.left = P\nP.left = n2\n// Removing node P\nn1.left = n2\n
    binary_tree.rb
    \n
    binary_tree.zig
    \n
    Code visualization

    https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5%0A%0A%20%20%20%20%23%20%E6%8F%92%E5%85%A5%E4%B8%8E%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%0A%20%20%20%20p%20%3D%20TreeNode%280%29%0A%20%20%20%20%23%20%E5%9C%A8%20n1%20-%3E%20n2%20%E4%B8%AD%E9%97%B4%E6%8F%92%E5%85%A5%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20p%0A%20%20%20%20p.left%20%3D%20n2%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20n2&cumulative=false&curInstr=37&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false

    Note

    It's important to note that inserting nodes may change the original logical structure of the binary tree, while removing nodes usually means removing the node and all its subtrees. Therefore, in a binary tree, insertion and removal are usually performed through a set of operations to achieve meaningful actions.

    "},{"location":"chapter_tree/binary_tree/#713-common-types-of-binary-trees","title":"7.1.3 \u00a0 Common types of binary trees","text":""},{"location":"chapter_tree/binary_tree/#1-perfect-binary-tree","title":"1. \u00a0 Perfect binary tree","text":"

    As shown in the Figure 7-4 , in a \"perfect binary tree,\" all levels of nodes are fully filled. In a perfect binary tree, the degree of leaf nodes is \\(0\\), and the degree of all other nodes is \\(2\\); if the tree's height is \\(h\\), then the total number of nodes is \\(2^{h+1} - 1\\), showing a standard exponential relationship, reflecting the common phenomenon of cell division in nature.

    Tip

    Please note that in the Chinese community, a perfect binary tree is often referred to as a \"full binary tree.\"

    Figure 7-4 \u00a0 Perfect binary tree

    "},{"location":"chapter_tree/binary_tree/#2-complete-binary-tree","title":"2. \u00a0 Complete binary tree","text":"

    As shown in the Figure 7-5 , a \"complete binary tree\" has only the bottom level nodes not fully filled, and the bottom level nodes are filled as far left as possible.

    Figure 7-5 \u00a0 Complete binary tree

    "},{"location":"chapter_tree/binary_tree/#3-full-binary-tree","title":"3. \u00a0 Full binary tree","text":"

    As shown in the Figure 7-6 , a \"full binary tree\" has all nodes except leaf nodes having two children.

    Figure 7-6 \u00a0 Full binary tree

    "},{"location":"chapter_tree/binary_tree/#4-balanced-binary-tree","title":"4. \u00a0 Balanced binary tree","text":"

    As shown in the Figure 7-7 , in a \"balanced binary tree,\" the absolute difference in height between the left and right subtrees of any node does not exceed 1.

    Figure 7-7 \u00a0 Balanced binary tree

    "},{"location":"chapter_tree/binary_tree/#714-degeneration-of-binary-trees","title":"7.1.4 \u00a0 Degeneration of binary trees","text":"

    The Figure 7-8 shows the ideal and degenerate structures of binary trees. When every level of a binary tree is filled, it reaches the \"perfect binary tree\"; when all nodes are biased towards one side, the binary tree degenerates into a \"linked list\".

    • The perfect binary tree is the ideal situation, fully leveraging the \"divide and conquer\" advantage of binary trees.
    • A linked list is another extreme, where operations become linear, degrading the time complexity to \\(O(n)\\).

    Figure 7-8 \u00a0 The Best and Worst Structures of Binary Trees

    As shown in the Table 7-1 , in the best and worst structures, the number of leaf nodes, total number of nodes, and height of the binary tree reach their maximum or minimum values.

    Table 7-1 \u00a0 The Best and Worst Structures of Binary Trees

    Perfect binary tree Linked list Number of nodes at level \\(i\\) \\(2^{i-1}\\) \\(1\\) Number of leaf nodes in a tree with height \\(h\\) \\(2^h\\) \\(1\\) Total number of nodes in a tree with height \\(h\\) \\(2^{h+1} - 1\\) \\(h + 1\\) Height of a tree with \\(n\\) total nodes \\(\\log_2 (n+1) - 1\\) \\(n - 1\\)"},{"location":"chapter_tree/binary_tree_traversal/","title":"7.2 \u00a0 Binary tree traversal","text":"

    From the perspective of physical structure, a tree is a data structure based on linked lists, hence its traversal method involves accessing nodes one by one through pointers. However, a tree is a non-linear data structure, which makes traversing a tree more complex than traversing a linked list, requiring the assistance of search algorithms to achieve.

    Common traversal methods for binary trees include level-order traversal, preorder traversal, inorder traversal, and postorder traversal, among others.

    "},{"location":"chapter_tree/binary_tree_traversal/#721-level-order-traversal","title":"7.2.1 \u00a0 Level-order traversal","text":"

    As shown in the Figure 7-9 , \"level-order traversal\" traverses the binary tree from top to bottom, layer by layer, and accesses nodes in each layer in a left-to-right order.

    Level-order traversal essentially belongs to \"breadth-first traversal\", also known as \"breadth-first search (BFS)\", which embodies a \"circumferentially outward expanding\" layer-by-layer traversal method.

    Figure 7-9 \u00a0 Level-order traversal of a binary tree

    "},{"location":"chapter_tree/binary_tree_traversal/#1-code-implementation","title":"1. \u00a0 Code implementation","text":"

    Breadth-first traversal is usually implemented with the help of a \"queue\". The queue follows the \"first in, first out\" rule, while breadth-first traversal follows the \"layer-by-layer progression\" rule, the underlying ideas of the two are consistent. The implementation code is as follows:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # \u961f\u5217\u51fa\u961f\n        res.append(node.val)  # \u4fdd\u5b58\u8282\u70b9\u503c\n        if node.left is not None:\n            queue.append(node.left)  # \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if node.right is not None:\n            queue.append(node.right)  # \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    return res\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\n    queue<TreeNode *> queue;\n    queue.push(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    vector<int> vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // \u961f\u5217\u51fa\u961f\n        vec.push_back(node->val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node->left != nullptr)\n            queue.push(node->left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node->right != nullptr)\n            queue.push(node->right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return vec;\n}\n
    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\n    Queue<TreeNode> queue = new LinkedList<>();\n    queue.add(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    List<Integer> list = new ArrayList<>();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // \u961f\u5217\u51fa\u961f\n        list.add(node.val);           // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null)\n            queue.offer(node.left);   // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right != null)\n            queue.offer(node.right);  // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list;\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\n    Queue<TreeNode> queue = new();\n    queue.Enqueue(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    List<int> list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // \u961f\u5217\u51fa\u961f\n        list.Add(node.val!.Value);       // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null)\n            queue.Enqueue(node.left);    // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right != null)\n            queue.Enqueue(node.right);   // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list;\n}\n
    binary_tree_bfs.go
    /* \u5c42\u5e8f\u904d\u5386 */\nfunc levelOrder(root *TreeNode) []any {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    queue := list.New()\n    queue.PushBack(root)\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5207\u7247\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    nums := make([]any, 0)\n    for queue.Len() > 0 {\n        // \u961f\u5217\u51fa\u961f\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // \u4fdd\u5b58\u8282\u70b9\u503c\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\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\n    var queue: [TreeNode] = [root]\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // \u961f\u5217\u51fa\u961f\n        list.append(node.val) // \u4fdd\u5b58\u8282\u70b9\u503c\n        if let left = node.left {\n            queue.append(left) // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if let right = node.right {\n            queue.append(right) // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }\n    }\n    return list\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\n    const queue = [root];\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // \u961f\u5217\u51fa\u961f\n        list.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left) queue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right) queue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return 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\n    const queue = [root];\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // \u961f\u5217\u51fa\u961f\n        list.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left) {\n            queue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if (node.right) {\n            queue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }\n    }\n    return 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\n  Queue<TreeNode?> queue = Queue();\n  queue.add(root);\n  // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n  List<int> res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // \u961f\u5217\u51fa\u961f\n    res.add(node!.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n    if (node.left != null) queue.add(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n    if (node.right != null) queue.add(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n  }\n  return res;\n}\n
    binary_tree_bfs.rs
    /* \u5c42\u5e8f\u904d\u5386 */\nfn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    let mut que = VecDeque::new();\n    que.push_back(Rc::clone(&root));\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // \u961f\u5217\u51fa\u961f\n        vec.push(node.borrow().val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(Rc::clone(left)); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(Rc::clone(right)); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        };\n    }\n    vec\n}\n
    binary_tree_bfs.c
    /* \u5c42\u5e8f\u904d\u5386 */\nint *levelOrder(TreeNode *root, int *size) {\n    /* \u8f85\u52a9\u961f\u5217 */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* \u8f85\u52a9\u961f\u5217 */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // \u961f\u5217\u6307\u9488\n    front = 0, rear = 0;\n    // \u52a0\u5165\u6839\u8282\u70b9\n    queue[rear++] = root;\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    /* \u8f85\u52a9\u6570\u7ec4 */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // \u6570\u7ec4\u6307\u9488\n    index = 0;\n    while (front < rear) {\n        // \u961f\u5217\u51fa\u961f\n        node = queue[front++];\n        // \u4fdd\u5b58\u8282\u70b9\u503c\n        arr[index++] = node->val;\n        if (node->left != NULL) {\n            // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n            queue[rear++] = node->left;\n        }\n        if (node->right != NULL) {\n            // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n            queue[rear++] = node->right;\n        }\n    }\n    // \u66f4\u65b0\u6570\u7ec4\u957f\u5ea6\u7684\u503c\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // \u91ca\u653e\u8f85\u52a9\u6570\u7ec4\u7a7a\u95f4\n    free(queue);\n    return arr;\n}\n
    binary_tree_bfs.kt
    /* \u5c42\u5e8f\u904d\u5386 */\nfun levelOrder(root: TreeNode?): MutableList<Int> {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    val queue = LinkedList<TreeNode?>()\n    queue.add(root)\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    val list = ArrayList<Int>()\n    while (!queue.isEmpty()) {\n        val node = queue.poll() // \u961f\u5217\u51fa\u961f\n        list.add(node?.value!!) // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null) queue.offer(node.left) // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n\n        if (node.right != null) queue.offer(node.right) // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list\n}\n
    binary_tree_bfs.rb
    [class]{}-[func]{level_order}\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\n    const L = std.TailQueue(*inc.TreeNode(T));\n    var queue = L{};\n    var root_node = try mem_allocator.create(L.Node);\n    root_node.data = root;\n    queue.append(root_node); \n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    var list = std.ArrayList(T).init(std.heap.page_allocator);\n    while (queue.len > 0) {\n        var queue_node = queue.popFirst().?;    // \u961f\u5217\u51fa\u961f\n        var node = queue_node.data;\n        try list.append(node.val);              // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null) {\n            var tmp_node = try mem_allocator.create(L.Node);\n            tmp_node.data = node.left.?;\n            queue.append(tmp_node);             // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if (node.right != null) {\n            var tmp_node = try mem_allocator.create(L.Node);\n            tmp_node.data = node.right.?;\n            queue.append(tmp_node);             // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }        \n    }\n    return list;\n}\n
    Code Visualization

    Full Screen >

    "},{"location":"chapter_tree/binary_tree_traversal/#2-complexity-analysis","title":"2. \u00a0 Complexity analysis","text":"
    • Time complexity is \\(O(n)\\): All nodes are visited once, using \\(O(n)\\) time, where \\(n\\) is the number of nodes.
    • Space complexity is \\(O(n)\\): In the worst case, i.e., a full binary tree, before traversing to the lowest level, the queue can contain at most \\((n + 1) / 2\\) nodes at the same time, occupying \\(O(n)\\) space.
    "},{"location":"chapter_tree/binary_tree_traversal/#722-preorder-inorder-and-postorder-traversal","title":"7.2.2 \u00a0 Preorder, inorder, and postorder traversal","text":"

    Correspondingly, preorder, inorder, and postorder traversal all belong to \"depth-first traversal\", also known as \"depth-first search (DFS)\", which embodies a \"proceed to the end first, then backtrack and continue\" traversal method.

    The Figure 7-10 shows the working principle of performing a depth-first traversal on a binary tree. Depth-first traversal is like walking around the perimeter of the entire binary tree, encountering three positions at each node, corresponding to preorder traversal, inorder traversal, and postorder traversal.

    Figure 7-10 \u00a0 Preorder, inorder, and postorder traversal of a binary search tree

    "},{"location":"chapter_tree/binary_tree_traversal/#1-code-implementation_1","title":"1. \u00a0 Code implementation","text":"

    Depth-first search is usually implemented based on recursion:

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_tree_dfs.py
    def pre_order(root: TreeNode | None):\n    \"\"\"\u524d\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"\u4e2d\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"\u540e\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n
    binary_tree_dfs.cpp
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    vec.push_back(root->val);\n    preOrder(root->left);\n    preOrder(root->right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root->left);\n    vec.push_back(root->val);\n    inOrder(root->right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root->left);\n    postOrder(root->right);\n    vec.push_back(root->val);\n}\n
    binary_tree_dfs.java
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n
    binary_tree_dfs.cs
    /* \u524d\u5e8f\u904d\u5386 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n
    binary_tree_dfs.go
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n
    binary_tree_dfs.swift
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n
    binary_tree_dfs.js
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n
    binary_tree_dfs.ts
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n
    binary_tree_dfs.dart
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n
    binary_tree_dfs.rs
    /* \u524d\u5e8f\u904d\u5386 */\nfn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n        result.push(node.borrow().val);\n        result.append(&mut pre_order(node.borrow().left.as_ref()));\n        result.append(&mut pre_order(node.borrow().right.as_ref()));\n    }\n    result\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n        result.append(&mut in_order(node.borrow().left.as_ref()));\n        result.push(node.borrow().val);\n        result.append(&mut in_order(node.borrow().right.as_ref()));\n    }\n    result\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n        result.append(&mut post_order(node.borrow().left.as_ref()));\n        result.append(&mut post_order(node.borrow().right.as_ref()));\n        result.push(node.borrow().val);\n    }\n    result\n}\n
    binary_tree_dfs.c
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    arr[(*size)++] = root->val;\n    preOrder(root->left, size);\n    preOrder(root->right, size);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root->left, size);\n    arr[(*size)++] = root->val;\n    inOrder(root->right, size);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root->left, size);\n    postOrder(root->right, size);\n    arr[(*size)++] = root->val;\n}\n
    binary_tree_dfs.kt
    /* \u524d\u5e8f\u904d\u5386 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.add(root.value)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left)\n    list.add(root.value)\n    inOrder(root.right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root.value)\n}\n
    binary_tree_dfs.rb
    [class]{}-[func]{pre_order}\n\n[class]{}-[func]{in_order}\n\n[class]{}-[func]{post_order}\n
    binary_tree_dfs.zig
    // \u524d\u5e8f\u904d\u5386\nfn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    try list.append(root.?.val);\n    try preOrder(T, root.?.left);\n    try preOrder(T, root.?.right);\n}\n\n// \u4e2d\u5e8f\u904d\u5386\nfn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    try inOrder(T, root.?.left);\n    try list.append(root.?.val);\n    try inOrder(T, root.?.right);\n}\n\n// \u540e\u5e8f\u904d\u5386\nfn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    try postOrder(T, root.?.left);\n    try postOrder(T, root.?.right);\n    try list.append(root.?.val);\n}\n
    Code Visualization

    Full Screen >

    Tip

    Depth-first search can also be implemented based on iteration, interested readers can study this on their own.

    The Figure 7-11 shows the recursive process of preorder traversal of a binary tree, which can be divided into two opposite parts: \"recursion\" and \"return\".

    1. \"Recursion\" means starting a new method, the program accesses the next node in this process.
    2. \"Return\" means the function returns, indicating the current node has been fully accessed.
    <1><2><3><4><5><6><7><8><9><10><11>

    Figure 7-11 \u00a0 The recursive process of preorder traversal

    "},{"location":"chapter_tree/binary_tree_traversal/#2-complexity-analysis_1","title":"2. \u00a0 Complexity analysis","text":"
    • Time complexity is \\(O(n)\\): All nodes are visited once, using \\(O(n)\\) time.
    • Space complexity is \\(O(n)\\): In the worst case, i.e., the tree degrades into a linked list, the recursion depth reaches \\(n\\), the system occupies \\(O(n)\\) stack frame space.
    "},{"location":"chapter_tree/summary/","title":"7.6 \u00a0 Summary","text":""},{"location":"chapter_tree/summary/#1-key-review","title":"1. \u00a0 Key review","text":"
    • A binary tree is a non-linear data structure that reflects the \"divide and conquer\" logic of splitting one into two. Each binary tree node contains a value and two pointers, which point to its left and right child nodes, respectively.
    • For a node in a binary tree, the tree formed by its left (right) child node and all nodes under it is called the node's left (right) subtree.
    • Related terminology of binary trees includes root node, leaf node, level, degree, edge, height, and depth, among others.
    • The operations of initializing a binary tree, inserting nodes, and removing nodes are similar to those of linked list operations.
    • Common types of binary trees include perfect binary trees, complete binary trees, full binary trees, and balanced binary trees. The perfect binary tree represents the ideal state, while the linked list is the worst state after degradation.
    • A binary tree can be represented using an array by arranging the node values and empty slots in a level-order traversal sequence and implementing pointers based on the index mapping relationship between parent nodes and child nodes.
    • The level-order traversal of a binary tree is a breadth-first search method, which reflects a layer-by-layer traversal manner of \"expanding circle by circle.\" It is usually implemented using a queue.
    • Pre-order, in-order, and post-order traversals are all depth-first search methods, reflecting the traversal manner of \"going to the end first, then backtracking to continue.\" They are usually implemented using recursion.
    • A binary search tree is an efficient data structure for element searching, with the time complexity of search, insert, and remove operations all being \\(O(\\log n)\\). When a binary search tree degrades into a linked list, these time complexities deteriorate to \\(O(n)\\).
    • An AVL tree, also known as a balanced binary search tree, ensures that the tree remains balanced after continuous node insertions and removals through rotation operations.
    • Rotation operations in an AVL tree include right rotation, left rotation, right-then-left rotation, and left-then-right rotation. After inserting or removing nodes, an AVL tree performs rotation operations from bottom to top to rebalance the tree.
    "},{"location":"chapter_tree/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q: For a binary tree with only one node, are both the height of the tree and the depth of the root node \\(0\\)?

    Yes, because height and depth are typically defined as \"the number of edges passed.\"

    Q: The insertion and removal in a binary tree are generally completed by a set of operations. What does \"a set of operations\" refer to here? Can it be understood as the release of resources of the child nodes?

    Taking the binary search tree as an example, the operation of removing a node needs to be handled in three different scenarios, each requiring multiple steps of node operations.

    Q: Why are there three sequences: pre-order, in-order, and post-order for DFS traversal of a binary tree, and what are their uses?

    Similar to sequential and reverse traversal of arrays, pre-order, in-order, and post-order traversals are three methods of traversing a binary tree, allowing us to obtain a traversal result in a specific order. For example, in a binary search tree, since the node sizes satisfy left child node value < root node value < right child node value, we can obtain an ordered node sequence by traversing the tree in the \"left \u2192 root \u2192 right\" priority.

    Q: In a right rotation operation that deals with the relationship between the imbalance nodes node, child, grand_child, isn't the connection between node and its parent node and the original link of node lost after the right rotation?

    We need to view this problem from a recursive perspective. The right_rotate(root) operation passes the root node of the subtree and eventually returns the root node of the rotated subtree with return child. The connection between the subtree's root node and its parent node is established after this function returns, which is outside the scope of the right rotation operation's maintenance.

    Q: In C++, functions are divided into private and public sections. What considerations are there for this? Why are the height() function and the updateHeight() function placed in public and private, respectively?

    It depends on the scope of the method's use. If a method is only used within the class, then it is designed to be private. For example, it makes no sense for users to call updateHeight() on their own, as it is just a step in the insertion or removal operations. However, height() is for accessing node height, similar to vector.size(), thus it is set to public for use.

    Q: How do you build a binary search tree from a set of input data? Is the choice of root node very important?

    Yes, the method for building the tree is provided in the build_tree() method in the binary search tree code. As for the choice of the root node, we usually sort the input data and then select the middle element as the root node, recursively building the left and right subtrees. This approach maximizes the balance of the tree.

    Q: In Java, do you always have to use the equals() method for string comparison?

    In Java, for primitive data types, == is used to compare whether the values of two variables are equal. For reference types, the working principles of the two symbols are different.

    • ==: Used to compare whether two variables point to the same object, i.e., whether their positions in memory are the same.
    • equals(): Used to compare whether the values of two objects are equal.

    Therefore, to compare values, we should use equals(). However, strings initialized with String a = \"hi\"; String b = \"hi\"; are stored in the string constant pool and point to the same object, so a == b can also be used to compare the contents of two strings.

    Q: Before reaching the bottom level, is the number of nodes in the queue \\(2^h\\) in breadth-first traversal?

    Yes, for example, a full binary tree with height \\(h = 2\\) has a total of \\(n = 7\\) nodes, then the bottom level has \\(4 = 2^h = (n + 1) / 2\\) nodes.

    "}]} \ No newline at end of file diff --git a/en/sitemap.xml b/en/sitemap.xml index 177628078..11f468328 100644 --- a/en/sitemap.xml +++ b/en/sitemap.xml @@ -2,187 +2,272 @@ https://www.hello-algo.com/en/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_array_and_linkedlist/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_array_and_linkedlist/array/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_array_and_linkedlist/linked_list/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_array_and_linkedlist/list/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_array_and_linkedlist/ram_and_cache/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_array_and_linkedlist/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_computational_complexity/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_computational_complexity/iteration_and_recursion/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_computational_complexity/performance_evaluation/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_computational_complexity/space_complexity/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_computational_complexity/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_computational_complexity/time_complexity/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_data_structure/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_data_structure/basic_data_types/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_data_structure/character_encoding/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_data_structure/classification_of_data_structure/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_data_structure/number_encoding/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_data_structure/summary/ - 2024-04-01 + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_graph/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_graph/graph/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_graph/graph_operations/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_graph/graph_traversal/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_graph/summary/ + 2024-04-02 daily https://www.hello-algo.com/en/chapter_hashing/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_hashing/hash_algorithm/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_hashing/hash_collision/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_hashing/hash_map/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_hashing/summary/ - 2024-04-01 + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_heap/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_heap/build_heap/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_heap/heap/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_heap/summary/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_heap/top_k/ + 2024-04-02 daily https://www.hello-algo.com/en/chapter_introduction/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_introduction/algorithms_are_everywhere/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_introduction/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_introduction/what_is_dsa/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_preface/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_preface/about_the_book/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_preface/suggestions/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_preface/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_stack_and_queue/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_stack_and_queue/deque/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_stack_and_queue/queue/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_stack_and_queue/stack/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/en/chapter_stack_and_queue/summary/ - 2024-04-01 + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_tree/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_tree/array_representation_of_tree/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_tree/avl_tree/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_tree/binary_search_tree/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_tree/binary_tree/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_tree/binary_tree_traversal/ + 2024-04-02 + daily + + + https://www.hello-algo.com/en/chapter_tree/summary/ + 2024-04-02 daily \ No newline at end of file diff --git a/en/sitemap.xml.gz b/en/sitemap.xml.gz index 88bc25998c94e02b7227931b304809df8e7f22da..52b5989dc56b5429fcb93abec449a1d73d8b27c2 100644 GIT binary patch literal 598 zcmV-c0;&BUiwFp!7nhg*;~J$ zJ$r;BVh@fTBpH^!uamG8j=gkHGt49wis#9eWLw$3fAnE-LSmodTlKnHR|||bwLW%l z)vupFmS3y)=4G2HFv_ARM}DiE$nd?c&*$@sy1+@r14M8!5L**`JYX9GK@$7K9PegSATO?0 zMQu|kCsPH7hX?Ah$ftx?OT?jqAsrca*@spSt{PBHeky4&hi51CQ7E-#f2$z5KCs>v zGB!YCeF^DucKG}!q6aIK`11qv*?}0(re%0`?tyR*7PVl)E@d&|(Ckt=XrboZb;v5t zM1PP~gdGdm!}KxWm@%U^+!l}epjD3a)K&+rBM5~MRWQ!qatTY4V~lbu80#_M6!gIE kd@Rmu7=f%)hpmxUPZe__|7YoKx-m-g8&He!uCFEl0Bx}u=Kufz literal 508 zcmV1Wf-^IVf*bTCmJ;?R&DbAy_zu-Vl=s_to%pT)ph zD^F{K?iMR_H8Y~MVGDK$wGOU9-?Yu5bNdSryU=$pyO(d3X4j9!I&nUI9xXK@6*eE8hAOLHKTkU1K?E)3x) zJDhxS2f2eGWa1owMgg7siMf<&QHX{|CyH7Jn|I6tHZ^zD%jJU*ULhH0Jjc-ISwcW4 z+_8S89p$6ovP;K!nMZv5b>+?riBU3-z{-&72_Bt$ig?UNA1Rn{2#FPss16~Vq)<~D y2Bal4NDi`yv?B(6DpxA!gbAhL_IQ>DEwZOeTO9PiO2SeQa`y+`$Ed~@8vp<+
  • 16.1 \u00a0 \u7f16\u7a0b\u73af\u5883\u5b89\u88c5
  • 16.2 \u00a0 \u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c
  • 16.3 \u00a0 \u672f\u8bed\u8868
    • "},{"location":"chapter_appendix/contribution/","title":"16.2 \u00a0 \u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c","text":"

    \u7531\u4e8e\u7b14\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\u94fe\u63a5\u5931\u6548\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\u7ed9\u8bfb\u8005\u63d0\u4f9b\u66f4\u4f18\u8d28\u7684\u5b66\u4e60\u8d44\u6e90\u3002

    \u6240\u6709\u64b0\u7a3f\u4eba\u7684 GitHub ID \u5c06\u5728\u672c\u4e66\u4ed3\u5e93\u3001\u7f51\u9875\u7248\u548c PDF \u7248\u7684\u4e3b\u9875\u4e0a\u8fdb\u884c\u5c55\u793a\uff0c\u4ee5\u611f\u8c22\u4ed6\u4eec\u5bf9\u5f00\u6e90\u793e\u533a\u7684\u65e0\u79c1\u5949\u732e\u3002

    \u5f00\u6e90\u7684\u9b45\u529b

    \u7eb8\u8d28\u56fe\u4e66\u7684\u4e24\u6b21\u5370\u5237\u7684\u95f4\u9694\u65f6\u95f4\u5f80\u5f80\u8f83\u4e45\uff0c\u5185\u5bb9\u66f4\u65b0\u975e\u5e38\u4e0d\u65b9\u4fbf\u3002

    \u800c\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

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

    \u5982\u56fe 16-3 \u6240\u793a\uff0c\u6bcf\u4e2a\u9875\u9762\u7684\u53f3\u4e0a\u89d2\u90fd\u6709\u201c\u7f16\u8f91\u56fe\u6807\u201d\u3002\u60a8\u53ef\u4ee5\u6309\u7167\u4ee5\u4e0b\u6b65\u9aa4\u4fee\u6539\u6587\u672c\u6216\u4ee3\u7801\u3002

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

    \u56fe 16-3 \u00a0 \u9875\u9762\u7f16\u8f91\u6309\u952e

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

    "},{"location":"chapter_appendix/contribution/#2","title":"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\u4ee5\u4e0b Pull Request \u5de5\u4f5c\u6d41\u7a0b\u3002

    1. \u767b\u5f55 GitHub \uff0c\u5c06\u672c\u4e66\u7684\u4ee3\u7801\u4ed3\u5e93 Fork \u5230\u4e2a\u4eba\u8d26\u53f7\u4e0b\u3002
    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\u3002
    3. \u5728\u672c\u5730\u8fdb\u884c\u5185\u5bb9\u521b\u4f5c\uff0c\u5e76\u8fdb\u884c\u5b8c\u6574\u6d4b\u8bd5\uff0c\u9a8c\u8bc1\u4ee3\u7801\u7684\u6b63\u786e\u6027\u3002
    4. \u5c06\u672c\u5730\u6240\u505a\u66f4\u6539 Commit \uff0c\u7136\u540e Push \u81f3\u8fdc\u7a0b\u4ed3\u5e93\u3002
    5. \u5237\u65b0\u4ed3\u5e93\u7f51\u9875\uff0c\u70b9\u51fb\u201cCreate pull request\u201d\u6309\u94ae\u5373\u53ef\u53d1\u8d77\u62c9\u53d6\u8bf7\u6c42\u3002
    "},{"location":"chapter_appendix/contribution/#3-docker","title":"3. \u00a0 Docker \u90e8\u7f72","text":"

    \u5728 hello-algo \u6839\u76ee\u5f55\u4e0b\uff0c\u6267\u884c\u4ee5\u4e0b Docker \u811a\u672c\uff0c\u5373\u53ef\u5728 http://localhost:8000 \u8bbf\u95ee\u672c\u9879\u76ee\uff1a

    docker-compose up -d\n

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

    docker-compose down\n
    "},{"location":"chapter_appendix/installation/","title":"16.1 \u00a0 \u7f16\u7a0b\u73af\u5883\u5b89\u88c5","text":""},{"location":"chapter_appendix/installation/#1611-ide","title":"16.1.1 \u00a0 \u5b89\u88c5 IDE","text":"

    \u63a8\u8350\u4f7f\u7528\u5f00\u6e90\u3001\u8f7b\u91cf\u7684 VS Code \u4f5c\u4e3a\u672c\u5730\u96c6\u6210\u5f00\u53d1\u73af\u5883\uff08IDE\uff09\u3002\u8bbf\u95ee VS Code \u5b98\u7f51\uff0c\u6839\u636e\u64cd\u4f5c\u7cfb\u7edf\u9009\u62e9\u76f8\u5e94\u7248\u672c\u7684 VS Code \u8fdb\u884c\u4e0b\u8f7d\u548c\u5b89\u88c5\u3002

    \u56fe 16-1 \u00a0 \u4ece\u5b98\u7f51\u4e0b\u8f7d VS Code

    VS Code \u62e5\u6709\u5f3a\u5927\u7684\u6269\u5c55\u5305\u751f\u6001\u7cfb\u7edf\uff0c\u652f\u6301\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u7684\u8fd0\u884c\u548c\u8c03\u8bd5\u3002\u4ee5 Python \u4e3a\u4f8b\uff0c\u5b89\u88c5\u201cPython Extension Pack\u201d\u6269\u5c55\u5305\u4e4b\u540e\uff0c\u5373\u53ef\u8fdb\u884c Python \u4ee3\u7801\u8c03\u8bd5\u3002\u5b89\u88c5\u6b65\u9aa4\u5982\u56fe 16-2 \u6240\u793a\u3002

    \u56fe 16-2 \u00a0 \u5b89\u88c5 VS Code \u6269\u5c55\u5305

    "},{"location":"chapter_appendix/installation/#1612","title":"16.1.2 \u00a0 \u5b89\u88c5\u8bed\u8a00\u73af\u5883","text":""},{"location":"chapter_appendix/installation/#1-python","title":"1. \u00a0 Python \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Miniconda3 \uff0c\u9700\u8981 Python 3.10 \u6216\u66f4\u65b0\u7248\u672c\u3002
    2. \u5728 VS Code \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/#2-cc","title":"2. \u00a0 C/C++ \u73af\u5883","text":"
    1. Windows \u7cfb\u7edf\u9700\u8981\u5b89\u88c5 MinGW\uff08\u914d\u7f6e\u6559\u7a0b\uff09\uff1bMacOS \u81ea\u5e26 Clang \uff0c\u65e0\u987b\u5b89\u88c5\u3002
    2. \u5728 VS Code \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/#3-java","title":"3. \u00a0 Java \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 OpenJDK\uff08\u7248\u672c\u9700\u6ee1\u8db3 > JDK 9\uff09\u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 java \uff0c\u5b89\u88c5 Extension Pack for Java \u3002
    "},{"location":"chapter_appendix/installation/#4-c","title":"4. \u00a0 C# \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 .Net 8.0 \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 C# Dev Kit \uff0c\u5b89\u88c5 C# Dev Kit \uff08\u914d\u7f6e\u6559\u7a0b\uff09\u3002
    3. \u4e5f\u53ef\u4f7f\u7528 Visual Studio\uff08\u5b89\u88c5\u6559\u7a0b\uff09\u3002
    "},{"location":"chapter_appendix/installation/#5-go","title":"5. \u00a0 Go \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 go \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 go \uff0c\u5b89\u88c5 Go \u3002
    3. \u6309\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/#6-swift","title":"6. \u00a0 Swift \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Swift \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 swift \uff0c\u5b89\u88c5 Swift for Visual Studio Code \u3002
    "},{"location":"chapter_appendix/installation/#7-javascript","title":"7. \u00a0 JavaScript \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 node.js \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 javascript \uff0c\u5b89\u88c5 JavaScript (ES6) code snippets \u3002
    3. \uff08\u53ef\u9009\uff09\u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 Prettier \uff0c\u5b89\u88c5\u4ee3\u7801\u683c\u5f0f\u5316\u5de5\u5177\u3002
    "},{"location":"chapter_appendix/installation/#8-dart","title":"8. \u00a0 Dart \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Dart \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 dart \uff0c\u5b89\u88c5 Dart \u3002
    "},{"location":"chapter_appendix/installation/#9-rust","title":"9. \u00a0 Rust \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Rust \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 rust \uff0c\u5b89\u88c5 rust-analyzer \u3002
    "},{"location":"chapter_appendix/terminology/","title":"16.3 \u00a0 \u672f\u8bed\u8868","text":"

    \u8868 16-1 \u5217\u51fa\u4e86\u4e66\u4e2d\u51fa\u73b0\u7684\u91cd\u8981\u672f\u8bed\uff0c\u503c\u5f97\u6ce8\u610f\u4ee5\u4e0b\u51e0\u70b9\u3002

    • \u5efa\u8bae\u8bb0\u4f4f\u540d\u8bcd\u7684\u82f1\u6587\u53eb\u6cd5\uff0c\u4ee5\u4fbf\u9605\u8bfb\u82f1\u6587\u6587\u732e\u3002
    • \u90e8\u5206\u540d\u8bcd\u5728\u7b80\u4f53\u4e2d\u6587\u548c\u7e41\u4f53\u4e2d\u6587\u4e0b\u7684\u53eb\u6cd5\u4e0d\u540c\u3002

    \u8868 16-1 \u00a0 \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u91cd\u8981\u540d\u8bcd

    English \u7b80\u4f53\u4e2d\u6587 \u7e41\u4f53\u4e2d\u6587 algorithm \u7b97\u6cd5 \u6f14\u7b97\u6cd5 data structure \u6570\u636e\u7ed3\u6784 \u8cc7\u6599\u7d50\u69cb code \u4ee3\u7801 \u7a0b\u5f0f\u78bc file \u6587\u4ef6 \u6a94\u6848 function \u51fd\u6570 \u51fd\u5f0f method \u65b9\u6cd5 \u65b9\u6cd5 variable \u53d8\u91cf \u8b8a\u6578 asymptotic complexity analysis \u6e10\u8fd1\u590d\u6742\u5ea6\u5206\u6790 \u6f38\u8fd1\u8907\u96dc\u5ea6\u5206\u6790 time complexity \u65f6\u95f4\u590d\u6742\u5ea6 \u6642\u9593\u8907\u96dc\u5ea6 space complexity \u7a7a\u95f4\u590d\u6742\u5ea6 \u7a7a\u9593\u8907\u96dc\u5ea6 loop \u5faa\u73af \u8ff4\u5708 iteration \u8fed\u4ee3 \u8fed\u4ee3 recursion \u9012\u5f52 \u905e\u8ff4 tail recursion \u5c3e\u9012\u5f52 \u5c3e\u905e\u8ff4 recursion tree \u9012\u5f52\u6811 \u905e\u8ff4\u6a39 big-\\(O\\) notation \u5927 \\(O\\) \u8bb0\u53f7 \u5927 \\(O\\) \u8a18\u865f asymptotic upper bound \u6e10\u8fd1\u4e0a\u754c \u6f38\u8fd1\u4e0a\u754c sign-magnitude \u539f\u7801 \u539f\u78bc 1\u2019s complement \u53cd\u7801 \u53cd\u78bc 2\u2019s complement \u8865\u7801 \u88dc\u78bc array \u6570\u7ec4 \u9663\u5217 index \u7d22\u5f15 \u7d22\u5f15 linked list \u94fe\u8868 \u93c8\u7d50\u4e32\u5217 linked list node, list node \u94fe\u8868\u8282\u70b9 \u93c8\u7d50\u4e32\u5217\u7bc0\u9ede head node \u5934\u8282\u70b9 \u982d\u7bc0\u9ede tail node \u5c3e\u8282\u70b9 \u5c3e\u7bc0\u9ede list \u5217\u8868 \u5217\u8868 dynamic array \u52a8\u6001\u6570\u7ec4 \u52d5\u614b\u9663\u5217 hard disk \u786c\u76d8 \u786c\u789f random-access memory (RAM) \u5185\u5b58 \u5167\u5b58 cache memory \u7f13\u5b58 \u5feb\u53d6 cache miss \u7f13\u5b58\u672a\u547d\u4e2d \u5feb\u53d6\u672a\u547d\u4e2d cache hit rate \u7f13\u5b58\u547d\u4e2d\u7387 \u5feb\u53d6\u547d\u4e2d\u7387 stack \u6808 \u5806\u758a top of the stack \u6808\u9876 \u5806\u758a\u9802 bottom of the stack \u6808\u5e95 \u5806\u758a\u5e95 queue \u961f\u5217 \u4f47\u5217 double-ended queue \u53cc\u5411\u961f\u5217 \u96d9\u5411\u4f47\u5217 front of the queue \u961f\u9996 \u4f47\u5217\u9996 rear of the queue \u961f\u5c3e \u4f47\u5217\u5c3e hash table \u54c8\u5e0c\u8868 \u96dc\u6e4a\u8868 bucket \u6876 \u6876 hash function \u54c8\u5e0c\u51fd\u6570 \u96dc\u6e4a\u51fd\u5f0f hash collision \u54c8\u5e0c\u51b2\u7a81 \u96dc\u6e4a\u885d\u7a81 load factor \u8d1f\u8f7d\u56e0\u5b50 \u8ca0\u8f09\u56e0\u5b50 separate chaining \u94fe\u5f0f\u5730\u5740 \u93c8\u7d50\u4f4d\u5740 open addressing \u5f00\u653e\u5bfb\u5740 \u958b\u653e\u5b9a\u5740 linear probing \u7ebf\u6027\u63a2\u6d4b \u7dda\u6027\u63a2\u67e5 lazy deletion \u61d2\u5220\u9664 \u61f6\u522a\u9664 binary tree \u4e8c\u53c9\u6811 \u4e8c\u5143\u6a39 tree node \u6811\u8282\u70b9 \u6a39\u7bc0\u9ede left-child node \u5de6\u5b50\u8282\u70b9 \u5de6\u5b50\u7bc0\u9ede right-child node \u53f3\u5b50\u8282\u70b9 \u53f3\u5b50\u7bc0\u9ede parent node \u7236\u8282\u70b9 \u7236\u7bc0\u9ede left subtree \u5de6\u5b50\u6811 \u5de6\u5b50\u6a39 right subtree \u53f3\u5b50\u6811 \u53f3\u5b50\u6a39 root node \u6839\u8282\u70b9 \u6839\u7bc0\u9ede leaf node \u53f6\u8282\u70b9 \u8449\u7bc0\u9ede edge \u8fb9 \u908a level \u5c42 \u5c64 degree \u5ea6 \u5ea6 height \u9ad8\u5ea6 \u9ad8\u5ea6 depth \u6df1\u5ea6 \u6df1\u5ea6 perfect binary tree \u5b8c\u7f8e\u4e8c\u53c9\u6811 \u5b8c\u7f8e\u4e8c\u5143\u6a39 complete binary tree \u5b8c\u5168\u4e8c\u53c9\u6811 \u5b8c\u5168\u4e8c\u5143\u6a39 full binary tree \u5b8c\u6ee1\u4e8c\u53c9\u6811 \u5b8c\u6eff\u4e8c\u5143\u6a39 balanced binary tree \u5e73\u8861\u4e8c\u53c9\u6811 \u5e73\u8861\u4e8c\u5143\u6a39 binary search tree \u4e8c\u53c9\u641c\u7d22\u6811 \u4e8c\u5143\u641c\u5c0b\u6a39 AVL tree AVL \u6811 AVL \u6a39 red-black tree \u7ea2\u9ed1\u6811 \u7d05\u9ed1\u6a39 level-order traversal \u5c42\u5e8f\u904d\u5386 \u5c64\u5e8f\u8d70\u8a2a breadth-first traversal \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 \u5ee3\u5ea6\u512a\u5148\u8d70\u8a2a depth-first traversal \u6df1\u5ea6\u4f18\u5148\u904d\u5386 \u6df1\u5ea6\u512a\u5148\u8d70\u8a2a binary search tree \u4e8c\u53c9\u641c\u7d22\u6811 \u4e8c\u5143\u641c\u5c0b\u6a39 balanced binary search tree \u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811 \u5e73\u8861\u4e8c\u5143\u641c\u5c0b\u6a39 balance factor \u5e73\u8861\u56e0\u5b50 \u5e73\u8861\u56e0\u5b50 heap \u5806 \u5806\u7a4d max heap \u5927\u9876\u5806 \u5927\u9802\u5806\u7a4d min heap \u5c0f\u9876\u5806 \u5c0f\u9802\u5806\u7a4d priority queue \u4f18\u5148\u961f\u5217 \u512a\u5148\u4f47\u5217 heapify \u5806\u5316 \u5806\u7a4d\u5316 top-\\(k\\) problem Top-\\(k\\) \u95ee\u9898 Top-\\(k\\) \u554f\u984c graph \u56fe \u5716 vertex \u9876\u70b9 \u9802\u9ede undirected graph \u65e0\u5411\u56fe \u7121\u5411\u5716 directed graph \u6709\u5411\u56fe \u6709\u5411\u5716 connected graph \u8fde\u901a\u56fe \u9023\u901a\u5716 disconnected graph \u975e\u8fde\u901a\u56fe \u975e\u9023\u901a\u5716 weighted graph \u6709\u6743\u56fe \u6709\u6b0a\u5716 adjacency \u90bb\u63a5 \u9130\u63a5 path \u8def\u5f84 \u8def\u5f91 in-degree \u5165\u5ea6 \u5165\u5ea6 out-degree \u51fa\u5ea6 \u51fa\u5ea6 adjacency matrix \u90bb\u63a5\u77e9\u9635 \u9130\u63a5\u77e9\u9663 adjacency list \u90bb\u63a5\u8868 \u9130\u63a5\u8868 breadth-first search \u5e7f\u5ea6\u4f18\u5148\u641c\u7d22 \u5ee3\u5ea6\u512a\u5148\u641c\u5c0b depth-first search \u6df1\u5ea6\u4f18\u5148\u641c\u7d22 \u6df1\u5ea6\u512a\u5148\u641c\u5c0b binary search \u4e8c\u5206\u67e5\u627e \u4e8c\u5206\u641c\u5c0b searching algorithm \u641c\u7d22\u7b97\u6cd5 \u641c\u5c0b\u6f14\u7b97\u6cd5 sorting algorithm \u6392\u5e8f\u7b97\u6cd5 \u6392\u5e8f\u6f14\u7b97\u6cd5 selection sort \u9009\u62e9\u6392\u5e8f \u9078\u64c7\u6392\u5e8f bubble sort \u5192\u6ce1\u6392\u5e8f \u6ce1\u6cab\u6392\u5e8f insertion sort \u63d2\u5165\u6392\u5e8f \u63d2\u5165\u6392\u5e8f quick sort \u5feb\u901f\u6392\u5e8f \u5feb\u901f\u6392\u5e8f merge sort \u5f52\u5e76\u6392\u5e8f \u5408\u4f75\u6392\u5e8f heap sort \u5806\u6392\u5e8f \u5806\u7a4d\u6392\u5e8f bucket sort \u6876\u6392\u5e8f \u6876\u6392\u5e8f counting sort \u8ba1\u6570\u6392\u5e8f \u8a08\u6578\u6392\u5e8f radix sort \u57fa\u6570\u6392\u5e8f \u57fa\u6578\u6392\u5e8f divide and conquer \u5206\u6cbb \u5206\u6cbb hanota problem \u6c49\u8bfa\u5854\u95ee\u9898 \u6cb3\u5167\u5854\u554f\u984c backtracking algorithm \u56de\u6eaf\u7b97\u6cd5 \u56de\u6eaf\u6f14\u7b97\u6cd5 constraint \u7ea6\u675f \u7d04\u675f solution \u89e3 \u89e3 state \u72b6\u6001 \u72c0\u614b pruning \u526a\u679d \u526a\u679d permutations problem \u5168\u6392\u5217\u95ee\u9898 \u5168\u6392\u5217\u554f\u984c subset-sum problem \u5b50\u96c6\u548c\u95ee\u9898 \u5b50\u96c6\u5408\u554f\u984c \\(n\\)-queens problem \\(n\\) \u7687\u540e\u95ee\u9898 \\(n\\) \u7687\u540e\u554f\u984c dynamic programming \u52a8\u6001\u89c4\u5212 \u52d5\u614b\u898f\u5283 initial state \u521d\u59cb\u72b6\u6001 \u521d\u59cb\u72c0\u614b state-transition equation \u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b \u72c0\u614b\u8f49\u79fb\u65b9\u7a0b knapsack problem \u80cc\u5305\u95ee\u9898 \u80cc\u5305\u554f\u984c edit distance problem \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898 \u7de8\u8f2f\u8ddd\u96e2\u554f\u984c greedy algorithm \u8d2a\u5fc3\u7b97\u6cd5 \u8caa\u5a6a\u6f14\u7b97\u6cd5"},{"location":"chapter_array_and_linkedlist/","title":"\u7b2c 4 \u7ae0 \u00a0 \u6570\u7ec4\u4e0e\u94fe\u8868","text":"

    Abstract

    \u6570\u636e\u7ed3\u6784\u7684\u4e16\u754c\u5982\u540c\u4e00\u5835\u539a\u5b9e\u7684\u7816\u5899\u3002

    \u6570\u7ec4\u7684\u7816\u5757\u6574\u9f50\u6392\u5217\uff0c\u9010\u4e2a\u7d27\u8d34\u3002\u94fe\u8868\u7684\u7816\u5757\u5206\u6563\u5404\u5904\uff0c\u8fde\u63a5\u7684\u85e4\u8513\u81ea\u7531\u5730\u7a7f\u68ad\u4e8e\u7816\u7f1d\u4e4b\u95f4\u3002

    "},{"location":"chapter_array_and_linkedlist/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 4.1 \u00a0 \u6570\u7ec4
    • 4.2 \u00a0 \u94fe\u8868
    • 4.3 \u00a0 \u5217\u8868
    • 4.4 \u00a0 \u5185\u5b58\u4e0e\u7f13\u5b58 *
    • 4.5 \u00a0 \u5c0f\u7ed3
    "},{"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\u7684\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\u8be5\u5143\u7d20\u7684\u300c\u7d22\u5f15 index\u300d\u3002\u56fe 4-1 \u5c55\u793a\u4e86\u6570\u7ec4\u7684\u4e3b\u8981\u6982\u5ff5\u548c\u5b58\u50a8\u65b9\u5f0f\u3002

    \u56fe 4-1 \u00a0 \u6570\u7ec4\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f

    "},{"location":"chapter_array_and_linkedlist/array/#411","title":"4.1.1 \u00a0 \u6570\u7ec4\u5e38\u7528\u64cd\u4f5c","text":""},{"location":"chapter_array_and_linkedlist/array/#1","title":"1. \u00a0 \u521d\u59cb\u5316\u6570\u7ec4","text":"

    \u6211\u4eec\u53ef\u4ee5\u6839\u636e\u9700\u6c42\u9009\u7528\u6570\u7ec4\u7684\u4e24\u79cd\u521d\u59cb\u5316\u65b9\u5f0f\uff1a\u65e0\u521d\u59cb\u503c\u3001\u7ed9\u5b9a\u521d\u59cb\u503c\u3002\u5728\u672a\u6307\u5b9a\u521d\u59cb\u503c\u7684\u60c5\u51b5\u4e0b\uff0c\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4f1a\u5c06\u6570\u7ec4\u5143\u7d20\u521d\u59cb\u5316\u4e3a \\(0\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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.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\uff08\u9700\u8981\u624b\u52a8\u91ca\u653e\u7a7a\u95f4\uff09\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n
    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.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.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.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.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.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
    array.rs
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nlet arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]\nlet nums: Vec<i32> = vec![1, 3, 2, 5, 4];\n
    array.c
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n
    array.kt
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n
    array.rb
    # \u521d\u59cb\u5316\u6570\u7ec4\narr = Array.new(5, 0)\nnums = [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
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#2","title":"2. \u00a0 \u8bbf\u95ee\u5143\u7d20","text":"

    \u6570\u7ec4\u5143\u7d20\u88ab\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u8fd9\u610f\u5473\u7740\u8ba1\u7b97\u6570\u7ec4\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\u975e\u5e38\u5bb9\u6613\u3002\u7ed9\u5b9a\u6570\u7ec4\u5185\u5b58\u5730\u5740\uff08\u9996\u5143\u7d20\u5185\u5b58\u5730\u5740\uff09\u548c\u67d0\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u56fe 4-2 \u6240\u793a\u7684\u516c\u5f0f\u8ba1\u7b97\u5f97\u5230\u8be5\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\uff0c\u4ece\u800c\u76f4\u63a5\u8bbf\u95ee\u8be5\u5143\u7d20\u3002

    \u56fe 4-2 \u00a0 \u6570\u7ec4\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\u8ba1\u7b97

    \u89c2\u5bdf\u56fe 4-2 \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\u4f46\u4ece\u5730\u5740\u8ba1\u7b97\u516c\u5f0f\u7684\u89d2\u5ea6\u770b\uff0c\u7d22\u5f15\u672c\u8d28\u4e0a\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\u5b83\u7684\u7d22\u5f15\u4e3a \\(0\\) \u662f\u5408\u7406\u7684\u3002

    \u5728\u6570\u7ec4\u4e2d\u8bbf\u95ee\u5143\u7d20\u975e\u5e38\u9ad8\u6548\uff0c\u6211\u4eec\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u968f\u673a\u8bbf\u95ee\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u4e00\u4e2a\u5143\u7d20\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    random_index = random.randint(0, len(nums) - 1)\n    # \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    random_num = nums[random_index]\n    return random_num\n
    array.cpp
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n    // \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = rand() % size;\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.java
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int[] nums) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.cs
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // \u5728\u533a\u95f4 [0, nums.Length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = random.Next(nums.Length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.go
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunc randomAccess(nums []int) (randomNum int) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    randomIndex := rand.Intn(len(nums))\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    randomNum = nums[randomIndex]\n    return\n}\n
    array.swift
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunc randomAccess(nums: [Int]) -> Int {\n    // \u5728\u533a\u95f4 [0, nums.count) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    let randomIndex = nums.indices.randomElement()!\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n
    array.js
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunction randomAccess(nums) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    const random_index = Math.floor(Math.random() * nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    const random_num = nums[random_index];\n    return random_num;\n}\n
    array.ts
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunction randomAccess(nums: number[]): number {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    const random_index = Math.floor(Math.random() * nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    const random_num = nums[random_index];\n    return random_num;\n}\n
    array.dart
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(List<int> nums) {\n  // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n  int randomIndex = Random().nextInt(nums.length);\n  // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n
    array.rs
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfn random_access(nums: &[i32]) -> i32 {\n    // \u5728\u533a\u95f4 [0, nums.len()) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    let random_num = nums[random_index];\n    random_num\n}\n
    array.c
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n    // \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = rand() % size;\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.kt
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfun randomAccess(nums: IntArray): Int {\n    // \u5728\u533a\u95f4 [0, nums.size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n
    array.rb
    ### \u968f\u673a\u8bbf\u95ee\u5143\u7d20 ###\ndef random_access(nums)\n  # \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n  random_index = Random.rand 0...(nums.length - 1)\n\n  # \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n  nums[random_index]\nend\n
    array.zig
    // \u968f\u673a\u8bbf\u95ee\u5143\u7d20\nfn randomAccess(nums: []i32) i32 {\n    // \u5728\u533a\u95f4 [0, nums.len) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6574\u6570\n    var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    var randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#3","title":"3. \u00a0 \u63d2\u5165\u5143\u7d20","text":"

    \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\u5b58\u653e\u4efb\u4f55\u6570\u636e\u3002\u5982\u56fe 4-3 \u6240\u793a\uff0c\u5982\u679c\u60f3\u5728\u6570\u7ec4\u4e2d\u95f4\u63d2\u5165\u4e00\u4e2a\u5143\u7d20\uff0c\u5219\u9700\u8981\u5c06\u8be5\u5143\u7d20\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u4e4b\u540e\u518d\u628a\u5143\u7d20\u8d4b\u503c\u7ed9\u8be5\u7d22\u5f15\u3002

    \u56fe 4-3 \u00a0 \u6570\u7ec4\u63d2\u5165\u5143\u7d20\u793a\u4f8b

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u7531\u4e8e\u6570\u7ec4\u7684\u957f\u5ea6\u662f\u56fa\u5b9a\u7684\uff0c\u56e0\u6b64\u63d2\u5165\u4e00\u4e2a\u5143\u7d20\u5fc5\u5b9a\u4f1a\u5bfc\u81f4\u6570\u7ec4\u5c3e\u90e8\u5143\u7d20\u201c\u4e22\u5931\u201d\u3002\u6211\u4eec\u5c06\u8fd9\u4e2a\u95ee\u9898\u7684\u89e3\u51b3\u65b9\u6848\u7559\u5728\u201c\u5217\u8868\u201d\u7ae0\u8282\u4e2d\u8ba8\u8bba\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def insert(nums: list[int], num: int, index: int):\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\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num\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\n    for (int i = size - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    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\n    for (int i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (int i = nums.Length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\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\n    for i := len(nums) - 1; i > index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (let i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (let i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 _num */\nvoid insert(List<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\n  for (var i = nums.length - 1; i > index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // \u5c06 _num \u8d4b\u7ed9 index \u5904\u5143\u7d20\n  nums[index] = _num;\n}\n
    array.rs
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfn insert(nums: &mut Vec<i32>, num: i32, index: usize) {\n    // \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (int i = size - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    array.kt
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num\n}\n
    array.rb
    ### \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num ###\ndef insert(nums, num, index)\n  # \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n  nums[index] = num\nend\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\n    var i = nums.len - 1;\n    while (i > index) : (i -= 1) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#4","title":"4. \u00a0 \u5220\u9664\u5143\u7d20","text":"

    \u540c\u7406\uff0c\u5982\u56fe 4-4 \u6240\u793a\uff0c\u82e5\u60f3\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

    \u56fe 4-4 \u00a0 \u6570\u7ec4\u5220\u9664\u5143\u7d20\u793a\u4f8b

    \u8bf7\u6ce8\u610f\uff0c\u5220\u9664\u5143\u7d20\u5b8c\u6210\u540e\uff0c\u539f\u5148\u672b\u5c3e\u7684\u5143\u7d20\u53d8\u5f97\u201c\u65e0\u610f\u4e49\u201d\u4e86\uff0c\u6240\u4ee5\u6211\u4eec\u65e0\u987b\u7279\u610f\u53bb\u4fee\u6539\u5b83\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def remove(nums: list[int], index: int):\n    \"\"\"\u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20\"\"\"\n    # \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n
    array.cpp
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.java
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.cs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.go
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for i := index; i < len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n
    array.swift
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfunc remove(nums: inout [Int], index: Int) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n
    array.js
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfunction remove(nums, index) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (let i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.ts
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (let i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.dart
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nvoid remove(List<int> nums, int index) {\n  // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n  for (var i = index; i < nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n
    array.rs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfn remove(nums: &mut Vec<i32>, index: usize) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.c
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.kt
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfun remove(nums: IntArray, index: Int) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (i in index..<nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n
    array.rb
    ### \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 ###\ndef remove(nums, index)\n  # \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n  for i in index...nums.length\n    nums[i] = nums[i + 1] || 0\n  end\nend\n
    array.zig
    // \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    var i = index;\n    while (i < nums.len - 1) : (i += 1) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

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

    • \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\u201c\u65e0\u610f\u4e49\u201d\u7684\uff0c\u4f46\u8fd9\u6837\u505a\u4f1a\u9020\u6210\u90e8\u5206\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u3002
    "},{"location":"chapter_array_and_linkedlist/array/#5","title":"5. \u00a0 \u904d\u5386\u6570\u7ec4","text":"

    \u5728\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u6211\u4eec\u65e2\u53ef\u4ee5\u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\uff0c\u4e5f\u53ef\u4ee5\u76f4\u63a5\u904d\u5386\u83b7\u53d6\u6570\u7ec4\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def traverse(nums: list[int]):\n    \"\"\"\u904d\u5386\u6570\u7ec4\"\"\"\n    count = 0\n    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in range(len(nums)):\n        count += nums[i]\n    # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums:\n        count += num\n    # \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n
    array.cpp
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        count += nums[i];\n    }\n}\n
    array.java
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (int num : nums) {\n        count += num;\n    }\n}\n
    array.cs
    /* \u904d\u5386\u6570\u7ec4 */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < nums.Length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n
    array.go
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums []int) {\n    count := 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i := 0; i < len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for _, num := range nums {\n        count += num\n    }\n    // \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n
    array.swift
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums {\n        count += num\n    }\n    // \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n
    array.js
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums) {\n    let count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (let i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (const num of nums) {\n        count += num;\n    }\n}\n
    array.ts
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (let i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (const num of nums) {\n        count += num;\n    }\n}\n
    array.dart
    /* \u904d\u5386\u6570\u7ec4\u5143\u7d20 */\nvoid traverse(List<int> nums) {\n  int count = 0;\n  // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n  for (var i = 0; i < nums.length; i++) {\n    count += nums[i];\n  }\n  // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n  for (int _num in nums) {\n    count += _num;\n  }\n  // \u901a\u8fc7 forEach \u65b9\u6cd5\u904d\u5386\u6570\u7ec4\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n
    array.rs
    /* \u904d\u5386\u6570\u7ec4 */\nfn traverse(nums: &[i32]) {\n    let mut _count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums {\n        _count += num;\n    }\n}\n
    array.c
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        count += nums[i];\n    }\n}\n
    array.kt
    /* \u904d\u5386\u6570\u7ec4 */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (j: Int in nums) {\n        count += j\n    }\n}\n
    array.rb
    ### \u904d\u5386\u6570\u7ec4 ###\ndef traverse(nums)\n  count = 0\n\n  # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n  for num in nums\n    count += num\n  end\nend\n
    array.zig
    // \u904d\u5386\u6570\u7ec4\nfn traverse(nums: []i32) void {\n    var count: i32 = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    var i: i32 = 0;\n    while (i < nums.len) : (i += 1) {\n        count += nums[i];\n    }\n    count = 0;\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (nums) |num| {\n        count += num;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#6","title":"6. \u00a0 \u67e5\u627e\u5143\u7d20","text":"

    \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\u9700\u8981\u904d\u5386\u6570\u7ec4\uff0c\u6bcf\u8f6e\u5224\u65ad\u5143\u7d20\u503c\u662f\u5426\u5339\u914d\uff0c\u82e5\u5339\u914d\u5219\u8f93\u51fa\u5bf9\u5e94\u7d22\u5f15\u3002

    \u56e0\u4e3a\u6570\u7ec4\u662f\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u6240\u4ee5\u4e0a\u8ff0\u67e5\u627e\u64cd\u4f5c\u88ab\u79f0\u4e3a\u201c\u7ebf\u6027\u67e5\u627e\u201d\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def find(nums: list[int], target: int) -> int:\n    \"\"\"\u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n
    array.cpp
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i < size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.java
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int[] nums, int target) {\n    for (int i = 0; i < nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.cs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint Find(int[] nums, int target) {\n    for (int i = 0; i < nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.go
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i < len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n
    array.swift
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums: [Int], target: Int) -> Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n
    array.js
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums, target) {\n    for (let i = 0; i < nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n
    array.ts
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i < nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(List<int> nums, int target) {\n  for (var i = 0; i < nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n
    array.rs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfn find(nums: &[i32], target: i32) -> Option<usize> {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n
    array.c
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i < size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.kt
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target) return i\n    }\n    return -1\n}\n
    array.rb
    ### \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n
    array.zig
    // \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\nfn find(nums: []i32, target: i32) i32 {\n    for (nums, 0..) |num, i| {\n        if (num == target) return @intCast(i);\n    }\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#7","title":"7. \u00a0 \u6269\u5bb9\u6570\u7ec4","text":"

    \u5728\u590d\u6742\u7684\u7cfb\u7edf\u73af\u5883\u4e2d\uff0c\u7a0b\u5e8f\u96be\u4ee5\u4fdd\u8bc1\u6570\u7ec4\u4e4b\u540e\u7684\u5185\u5b58\u7a7a\u95f4\u662f\u53ef\u7528\u7684\uff0c\u4ece\u800c\u65e0\u6cd5\u5b89\u5168\u5730\u6269\u5c55\u6570\u7ec4\u5bb9\u91cf\u3002\u56e0\u6b64\u5728\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u6570\u7ec4\u7684\u957f\u5ea6\u662f\u4e0d\u53ef\u53d8\u7684\u3002

    \u5982\u679c\u6211\u4eec\u5e0c\u671b\u6269\u5bb9\u6570\u7ec4\uff0c\u5219\u9700\u91cd\u65b0\u5efa\u7acb\u4e00\u4e2a\u66f4\u5927\u7684\u6570\u7ec4\uff0c\u7136\u540e\u628a\u539f\u6570\u7ec4\u5143\u7d20\u4f9d\u6b21\u590d\u5236\u5230\u65b0\u6570\u7ec4\u3002\u8fd9\u662f\u4e00\u4e2a \\(O(n)\\) \u7684\u64cd\u4f5c\uff0c\u5728\u6570\u7ec4\u5f88\u5927\u7684\u60c5\u51b5\u4e0b\u975e\u5e38\u8017\u65f6\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    res = [0] * (len(nums) + enlarge)\n    # \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res\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\n    int *res = new int[size + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        res[i] = nums[i];\n    }\n    // \u91ca\u653e\u5185\u5b58\n    delete[] nums;\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    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\n    int[] res = new int[nums.length + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\n    int[] res = new int[nums.Length + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\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\n    res := make([]int, len(nums)+enlarge)\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for i, num := range nums {\n        res[i] = num\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\n    var 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\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\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\n    const 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\n    for (let i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\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\n    const 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\n    for (let i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    array.dart
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nList<int> extend(List<int> nums, int enlarge) {\n  // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n  List<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\n  for (var i = 0; i < nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n  return res;\n}\n
    array.rs
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfn extend(nums: Vec<i32>, enlarge: usize) -> Vec<i32> {\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n    let mut res: Vec<i32> = vec![0; nums.len() + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\n    for i in 0..nums.len() {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    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\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        res[i] = nums[i];\n    }\n    // \u521d\u59cb\u5316\u6269\u5c55\u540e\u7684\u7a7a\u95f4\n    for (int i = size; i < size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    array.kt
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n    val res = IntArray(nums.size + enlarge)\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res\n}\n
    array.rb
    ### \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 ###\n# \u8bf7\u6ce8\u610f\uff0cRuby \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\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6570\u7ec4\ndef extend(nums, enlarge)\n  # \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n  res = Array.new(nums.length + enlarge, 0)\n\n  # \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n  res\nend\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\n    var 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\n    std.mem.copy(i32, res, nums);\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#412","title":"4.1.2 \u00a0 \u6570\u7ec4\u7684\u4f18\u70b9\u4e0e\u5c40\u9650\u6027","text":"

    \u6570\u7ec4\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u5185\uff0c\u4e14\u5143\u7d20\u7c7b\u578b\u76f8\u540c\u3002\u8fd9\u79cd\u505a\u6cd5\u5305\u542b\u4e30\u5bcc\u7684\u5148\u9a8c\u4fe1\u606f\uff0c\u7cfb\u7edf\u53ef\u4ee5\u5229\u7528\u8fd9\u4e9b\u4fe1\u606f\u6765\u4f18\u5316\u6570\u636e\u7ed3\u6784\u7684\u64cd\u4f5c\u6548\u7387\u3002

    • \u7a7a\u95f4\u6548\u7387\u9ad8\uff1a\u6570\u7ec4\u4e3a\u6570\u636e\u5206\u914d\u4e86\u8fde\u7eed\u7684\u5185\u5b58\u5757\uff0c\u65e0\u987b\u989d\u5916\u7684\u7ed3\u6784\u5f00\u9500\u3002
    • \u652f\u6301\u968f\u673a\u8bbf\u95ee\uff1a\u6570\u7ec4\u5141\u8bb8\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u8bbf\u95ee\u4efb\u4f55\u5143\u7d20\u3002
    • \u7f13\u5b58\u5c40\u90e8\u6027\uff1a\u5f53\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

    \u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u662f\u4e00\u628a\u53cc\u5203\u5251\uff0c\u5176\u5b58\u5728\u4ee5\u4e0b\u5c40\u9650\u6027\u3002

    • \u63d2\u5165\u4e0e\u5220\u9664\u6548\u7387\u4f4e\uff1a\u5f53\u6570\u7ec4\u4e2d\u5143\u7d20\u8f83\u591a\u65f6\uff0c\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u9700\u8981\u79fb\u52a8\u5927\u91cf\u7684\u5143\u7d20\u3002
    • \u957f\u5ea6\u4e0d\u53ef\u53d8\uff1a\u6570\u7ec4\u5728\u521d\u59cb\u5316\u540e\u957f\u5ea6\u5c31\u56fa\u5b9a\u4e86\uff0c\u6269\u5bb9\u6570\u7ec4\u9700\u8981\u5c06\u6240\u6709\u6570\u636e\u590d\u5236\u5230\u65b0\u6570\u7ec4\uff0c\u5f00\u9500\u5f88\u5927\u3002
    • \u7a7a\u95f4\u6d6a\u8d39\uff1a\u5982\u679c\u6570\u7ec4\u5206\u914d\u7684\u5927\u5c0f\u8d85\u8fc7\u5b9e\u9645\u6240\u9700\uff0c\u90a3\u4e48\u591a\u4f59\u7684\u7a7a\u95f4\u5c31\u88ab\u6d6a\u8d39\u4e86\u3002
    "},{"location":"chapter_array_and_linkedlist/array/#413","title":"4.1.3 \u00a0 \u6570\u7ec4\u5178\u578b\u5e94\u7528","text":"

    \u6570\u7ec4\u662f\u4e00\u79cd\u57fa\u7840\u4e14\u5e38\u89c1\u7684\u6570\u636e\u7ed3\u6784\uff0c\u65e2\u9891\u7e41\u5e94\u7528\u5728\u5404\u7c7b\u7b97\u6cd5\u4e4b\u4e2d\uff0c\u4e5f\u53ef\u7528\u4e8e\u5b9e\u73b0\u5404\u79cd\u590d\u6742\u6570\u636e\u7ed3\u6784\u3002

    • \u968f\u673a\u8bbf\u95ee\uff1a\u5982\u679c\u6211\u4eec\u60f3\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\u968f\u673a\u62bd\u6837\u3002
    • \u6392\u5e8f\u548c\u641c\u7d22\uff1a\u6570\u7ec4\u662f\u6392\u5e8f\u548c\u641c\u7d22\u7b97\u6cd5\u6700\u5e38\u7528\u7684\u6570\u636e\u7ed3\u6784\u3002\u5feb\u901f\u6392\u5e8f\u3001\u5f52\u5e76\u6392\u5e8f\u3001\u4e8c\u5206\u67e5\u627e\u7b49\u90fd\u4e3b\u8981\u5728\u6570\u7ec4\u4e0a\u8fdb\u884c\u3002
    • \u67e5\u627e\u8868\uff1a\u5f53\u9700\u8981\u5feb\u901f\u67e5\u627e\u4e00\u4e2a\u5143\u7d20\u6216\u5176\u5bf9\u5e94\u5173\u7cfb\u65f6\uff0c\u53ef\u4ee5\u4f7f\u7528\u6570\u7ec4\u4f5c\u4e3a\u67e5\u627e\u8868\u3002\u5047\u5982\u6211\u4eec\u60f3\u5b9e\u73b0\u5b57\u7b26\u5230 ASCII \u7801\u7684\u6620\u5c04\uff0c\u5219\u53ef\u4ee5\u5c06\u5b57\u7b26\u7684 ASCII \u7801\u503c\u4f5c\u4e3a\u7d22\u5f15\uff0c\u5bf9\u5e94\u7684\u5143\u7d20\u5b58\u653e\u5728\u6570\u7ec4\u4e2d\u7684\u5bf9\u5e94\u4f4d\u7f6e\u3002
    • \u673a\u5668\u5b66\u4e60\uff1a\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
    • \u6570\u636e\u7ed3\u6784\u5b9e\u73b0\uff1a\u6570\u7ec4\u53ef\u4ee5\u7528\u4e8e\u5b9e\u73b0\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u5806\u3001\u56fe\u7b49\u6570\u636e\u7ed3\u6784\u3002\u4f8b\u5982\uff0c\u56fe\u7684\u90bb\u63a5\u77e9\u9635\u8868\u793a\u5b9e\u9645\u4e0a\u662f\u4e00\u4e2a\u4e8c\u7ef4\u6570\u7ec4\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\u5728\u4e00\u4e2a\u590d\u6742\u7684\u7cfb\u7edf\u8fd0\u884c\u73af\u5883\u4e0b\uff0c\u7a7a\u95f2\u7684\u5185\u5b58\u7a7a\u95f4\u53ef\u80fd\u6563\u843d\u5728\u5185\u5b58\u5404\u5904\u3002\u6211\u4eec\u77e5\u9053\uff0c\u5b58\u50a8\u6570\u7ec4\u7684\u5185\u5b58\u7a7a\u95f4\u5fc5\u987b\u662f\u8fde\u7eed\u7684\uff0c\u800c\u5f53\u6570\u7ec4\u975e\u5e38\u5927\u65f6\uff0c\u5185\u5b58\u53ef\u80fd\u65e0\u6cd5\u63d0\u4f9b\u5982\u6b64\u5927\u7684\u8fde\u7eed\u7a7a\u95f4\u3002\u6b64\u65f6\u94fe\u8868\u7684\u7075\u6d3b\u6027\u4f18\u52bf\u5c31\u4f53\u73b0\u51fa\u6765\u4e86\u3002

    \u300c\u94fe\u8868 linked list\u300d\u662f\u4e00\u79cd\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u5176\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\u90fd\u662f\u4e00\u4e2a\u8282\u70b9\u5bf9\u8c61\uff0c\u5404\u4e2a\u8282\u70b9\u901a\u8fc7\u201c\u5f15\u7528\u201d\u76f8\u8fde\u63a5\u3002\u5f15\u7528\u8bb0\u5f55\u4e86\u4e0b\u4e00\u4e2a\u8282\u70b9\u7684\u5185\u5b58\u5730\u5740\uff0c\u901a\u8fc7\u5b83\u53ef\u4ee5\u4ece\u5f53\u524d\u8282\u70b9\u8bbf\u95ee\u5230\u4e0b\u4e00\u4e2a\u8282\u70b9\u3002

    \u94fe\u8868\u7684\u8bbe\u8ba1\u4f7f\u5f97\u5404\u4e2a\u8282\u70b9\u53ef\u4ee5\u5206\u6563\u5b58\u50a8\u5728\u5185\u5b58\u5404\u5904\uff0c\u5b83\u4eec\u7684\u5185\u5b58\u5730\u5740\u65e0\u987b\u8fde\u7eed\u3002

    \u56fe 4-5 \u00a0 \u94fe\u8868\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f

    \u89c2\u5bdf\u56fe 4-5 \uff0c\u94fe\u8868\u7684\u7ec4\u6210\u5355\u4f4d\u662f\u300c\u8282\u70b9 node\u300d\u5bf9\u8c61\u3002\u6bcf\u4e2a\u8282\u70b9\u90fd\u5305\u542b\u4e24\u9879\u6570\u636e\uff1a\u8282\u70b9\u7684\u201c\u503c\u201d\u548c\u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u201c\u5f15\u7528\u201d\u3002

    • \u94fe\u8868\u7684\u9996\u4e2a\u8282\u70b9\u88ab\u79f0\u4e3a\u201c\u5934\u8282\u70b9\u201d\uff0c\u6700\u540e\u4e00\u4e2a\u8282\u70b9\u88ab\u79f0\u4e3a\u201c\u5c3e\u8282\u70b9\u201d\u3002
    • \u5c3e\u8282\u70b9\u6307\u5411\u7684\u662f\u201c\u7a7a\u201d\uff0c\u5b83\u5728 Java\u3001C++ \u548c Python \u4e2d\u5206\u522b\u88ab\u8bb0\u4e3a null\u3001nullptr \u548c None \u3002
    • \u5728 C\u3001C++\u3001Go \u548c Rust \u7b49\u652f\u6301\u6307\u9488\u7684\u8bed\u8a00\u4e2d\uff0c\u4e0a\u8ff0\u201c\u5f15\u7528\u201d\u5e94\u88ab\u66ff\u6362\u4e3a\u201c\u6307\u9488\u201d\u3002

    \u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u94fe\u8868\u8282\u70b9 ListNode \u9664\u4e86\u5305\u542b\u503c\uff0c\u8fd8\u9700\u989d\u5916\u4fdd\u5b58\u4e00\u4e2a\u5f15\u7528\uff08\u6307\u9488\uff09\u3002\u56e0\u6b64\u5728\u76f8\u540c\u6570\u636e\u91cf\u4e0b\uff0c\u94fe\u8868\u6bd4\u6570\u7ec4\u5360\u7528\u66f4\u591a\u7684\u5185\u5b58\u7a7a\u95f4\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class ListNode:\n    \"\"\"\u94fe\u8868\u8282\u70b9\u7c7b\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # \u8282\u70b9\u503c\n        self.next: ListNode | None = None # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\n    int val;         // \u8282\u70b9\u503c\n    ListNode *next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n    ListNode(int x) : val(x), next(nullptr) {}  // \u6784\u9020\u51fd\u6570\n};\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    int val;        // \u8282\u70b9\u503c\n    ListNode next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    ListNode(int x) { val = x; }  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode(int x) {  //\u6784\u9020\u51fd\u6570\n    int val = x;         // \u8282\u70b9\u503c\n    ListNode? next;      // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype ListNode struct {\n    Val  int       // \u8282\u70b9\u503c\n    Next *ListNode // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n}\n\n// NewListNode \u6784\u9020\u51fd\u6570\uff0c\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u94fe\u8868\nfunc NewListNode(val int) *ListNode {\n    return &ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    var val: Int // \u8282\u70b9\u503c\n    var next: ListNode? // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n\n    init(x: Int) { // \u6784\u9020\u51fd\u6570\n        val = x\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // \u8282\u70b9\u503c\n        this.next = (next === undefined ? null : next); // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // \u8282\u70b9\u503c\n        this.next = next === undefined ? null : next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n  int val; // \u8282\u70b9\u503c\n  ListNode? next; // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n  ListNode(this.val, [this.next]); // \u6784\u9020\u51fd\u6570\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n/* \u94fe\u8868\u8282\u70b9\u7c7b */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // \u8282\u70b9\u503c\n    next: Option<Rc<RefCell<ListNode>>>, // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct ListNode {\n    int val;               // \u8282\u70b9\u503c\n    struct ListNode *next; // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n} ListNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node->val = val;\n    node->next = NULL;\n    return node;\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\n// \u6784\u9020\u65b9\u6cd5\nclass ListNode(x: Int) {\n    val _val: Int = x          // \u8282\u70b9\u503c\n    val next: ListNode? = null // \u6307\u5411\u4e0b\u4e00\u4e2a\u8282\u70b9\u7684\u5f15\u7528\n}\n
    # \u94fe\u8868\u8282\u70b9\u7c7b\nclass ListNode\n  attr_accessor :val  # \u8282\u70b9\u503c\n  attr_accessor :next # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n
    // \u94fe\u8868\u8282\u70b9\u7c7b\npub fn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = 0, // \u8282\u70b9\u503c\n        next: ?*Self = null, // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n\n        // \u6784\u9020\u51fd\u6570\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n        }\n    };\n}\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#421","title":"4.2.1 \u00a0 \u94fe\u8868\u5e38\u7528\u64cd\u4f5c","text":""},{"location":"chapter_array_and_linkedlist/linked_list/#1","title":"1. \u00a0 \u521d\u59cb\u5316\u94fe\u8868","text":"

    \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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\u5173\u7cfb\u3002\u521d\u59cb\u5316\u5b8c\u6210\u540e\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u4ece\u94fe\u8868\u7684\u5934\u8282\u70b9\u51fa\u53d1\uff0c\u901a\u8fc7\u5f15\u7528\u6307\u5411 next \u4f9d\u6b21\u8bbf\u95ee\u6240\u6709\u8282\u70b9\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.rs
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.kt
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.rb
    # \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4\n# \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nn0 = ListNode.new 1\nn1 = ListNode.new 3\nn2 = ListNode.new 2\nn3 = ListNode.new 5\nn4 = ListNode.new 4\n# \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0.next = &n1;\nn1.next = &n2;\nn2.next = &n3;\nn3.next = &n4;\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6570\u7ec4\u6574\u4f53\u662f\u4e00\u4e2a\u53d8\u91cf\uff0c\u6bd4\u5982\u6570\u7ec4 nums \u5305\u542b\u5143\u7d20 nums[0] \u548c nums[1] \u7b49\uff0c\u800c\u94fe\u8868\u662f\u7531\u591a\u4e2a\u72ec\u7acb\u7684\u8282\u70b9\u5bf9\u8c61\u7ec4\u6210\u7684\u3002\u6211\u4eec\u901a\u5e38\u5c06\u5934\u8282\u70b9\u5f53\u4f5c\u94fe\u8868\u7684\u4ee3\u79f0\uff0c\u6bd4\u5982\u4ee5\u4e0a\u4ee3\u7801\u4e2d\u7684\u94fe\u8868\u53ef\u8bb0\u4f5c\u94fe\u8868 n0 \u3002

    "},{"location":"chapter_array_and_linkedlist/linked_list/#2","title":"2. \u00a0 \u63d2\u5165\u8282\u70b9","text":"

    \u5728\u94fe\u8868\u4e2d\u63d2\u5165\u8282\u70b9\u975e\u5e38\u5bb9\u6613\u3002\u5982\u56fe 4-6 \u6240\u793a\uff0c\u5047\u8bbe\u6211\u4eec\u60f3\u5728\u76f8\u90bb\u7684\u4e24\u4e2a\u8282\u70b9 n0 \u548c n1 \u4e4b\u95f4\u63d2\u5165\u4e00\u4e2a\u65b0\u8282\u70b9 P \uff0c\u5219\u53ea\u9700\u6539\u53d8\u4e24\u4e2a\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\u5373\u53ef\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002

    \u76f8\u6bd4\u4e4b\u4e0b\uff0c\u5728\u6570\u7ec4\u4e2d\u63d2\u5165\u5143\u7d20\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5728\u5927\u6570\u636e\u91cf\u4e0b\u7684\u6548\u7387\u8f83\u4f4e\u3002

    \u56fe 4-6 \u00a0 \u94fe\u8868\u63d2\u5165\u8282\u70b9\u793a\u4f8b

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def insert(n0: ListNode, P: ListNode):\n    \"\"\"\u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0->next;\n    P->next = n1;\n    n0->next = P;\n}\n
    linked_list.java
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.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) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n
    linked_list.go
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.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) {\n    let n1 = n0.next\n    P.next = n1\n    n0.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) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.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 {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.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) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n
    linked_list.rs
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\n#[allow(non_snake_case)]\npub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(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) {\n    ListNode *n1 = n0->next;\n    P->next = n1;\n    n0->next = P;\n}\n
    linked_list.kt
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9p */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n
    linked_list.rb
    ### \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 _p ###\n# Ruby \u7684 `p` \u662f\u4e00\u4e2a\u5185\u7f6e\u51fd\u6570\uff0c `P` \u662f\u4e00\u4e2a\u5e38\u91cf\uff0c\u6240\u4ee5\u53ef\u4ee5\u4f7f\u7528 `_p` \u4ee3\u66ff\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\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 {\n    var n1 = n0.?.next;\n    P.?.next = n1;\n    n0.?.next = P;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#3","title":"3. \u00a0 \u5220\u9664\u8282\u70b9","text":"

    \u5982\u56fe 4-7 \u6240\u793a\uff0c\u5728\u94fe\u8868\u4e2d\u5220\u9664\u8282\u70b9\u4e5f\u975e\u5e38\u65b9\u4fbf\uff0c\u53ea\u9700\u6539\u53d8\u4e00\u4e2a\u8282\u70b9\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\u5373\u53ef\u3002

    \u8bf7\u6ce8\u610f\uff0c\u5c3d\u7ba1\u5728\u5220\u9664\u64cd\u4f5c\u5b8c\u6210\u540e\u8282\u70b9 P \u4ecd\u7136\u6307\u5411 n1 \uff0c\u4f46\u5b9e\u9645\u4e0a\u904d\u5386\u6b64\u94fe\u8868\u5df2\u7ecf\u65e0\u6cd5\u8bbf\u95ee\u5230 P \uff0c\u8fd9\u610f\u5473\u7740 P \u5df2\u7ecf\u4e0d\u518d\u5c5e\u4e8e\u8be5\u94fe\u8868\u4e86\u3002

    \u56fe 4-7 \u00a0 \u94fe\u8868\u5220\u9664\u8282\u70b9

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def remove(n0: ListNode):\n    \"\"\"\u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9\"\"\"\n    if not n0.next:\n        return\n    # n0 -> P -> n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n
    linked_list.cpp
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode *n0) {\n    if (n0->next == nullptr)\n        return;\n    // n0 -> P -> n1\n    ListNode *P = n0->next;\n    ListNode *n1 = P->next;\n    n0->next = n1;\n    // \u91ca\u653e\u5185\u5b58\n    delete P;\n}\n
    linked_list.java
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -> P -> n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n
    linked_list.cs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -> P -> n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n
    linked_list.go
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -> P -> n1\n    P := n0.Next\n    n1 := P.Next\n    n0.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) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -> P -> n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.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) {\n    if (!n0.next) return;\n    // n0 -> P -> n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.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 {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -> P -> n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.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) {\n  if (n0.next == null) return;\n  // n0 -> P -> n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n
    linked_list.rs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\n#[allow(non_snake_case)]\npub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {\n    if n0.borrow().next.is_none() {\n        return;\n    };\n    // n0 -> P -> n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\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 removeItem(ListNode *n0) {\n    if (!n0->next)\n        return;\n    // n0 -> P -> n1\n    ListNode *P = n0->next;\n    ListNode *n1 = P->next;\n    n0->next = n1;\n    // \u91ca\u653e\u5185\u5b58\n    free(P);\n}\n
    linked_list.kt
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfun remove(n0: ListNode?) {\n    val p = n0?.next\n    val n1 = p?.next\n    n0?.next = n1\n}\n
    linked_list.rb
    ### \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -> remove_node -> n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\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 {\n    if (n0.?.next == null) return;\n    // n0 -> P -> n1\n    var P = n0.?.next;\n    var n1 = P.?.next;\n    n0.?.next = n1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#4","title":"4. \u00a0 \u8bbf\u95ee\u8282\u70b9","text":"

    \u5728\u94fe\u8868\u4e2d\u8bbf\u95ee\u8282\u70b9\u7684\u6548\u7387\u8f83\u4f4e\u3002\u5982\u4e0a\u4e00\u8282\u6240\u8ff0\uff0c\u6211\u4eec\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u4e0b\u8bbf\u95ee\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u5143\u7d20\u3002\u94fe\u8868\u5219\u4e0d\u7136\uff0c\u7a0b\u5e8f\u9700\u8981\u4ece\u5934\u8282\u70b9\u51fa\u53d1\uff0c\u9010\u4e2a\u5411\u540e\u904d\u5386\uff0c\u76f4\u81f3\u627e\u5230\u76ee\u6807\u8282\u70b9\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u8bbf\u95ee\u94fe\u8868\u7684\u7b2c \\(i\\) \u4e2a\u8282\u70b9\u9700\u8981\u5faa\u73af \\(i - 1\\) \u8f6e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def access(head: ListNode, index: int) -> ListNode | None:\n    \"\"\"\u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n
    linked_list.cpp
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head->next;\n    }\n    return head;\n}\n
    linked_list.java
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.cs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.go
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i < index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return 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? {\n    var head: ListNode? = head\n    for _ in 0 ..< index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n
    linked_list.js
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunction access(head, index) {\n    for (let i = 0; i < index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return 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 {\n    for (let i = 0; i < index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.dart
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i < index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n
    linked_list.rs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\npub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {\n    if index <= 0 {\n        return head;\n    };\n    if let Some(node) = &head.borrow().next {\n        return access(node.clone(), index - 1);\n    }\n\n    return head;\n}\n
    linked_list.c
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head->next;\n    }\n    return head;\n}\n
    linked_list.kt
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..<index) {\n        h = h?.next\n    }\n    return h\n}\n
    linked_list.rb
    ### \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\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) {\n    var head = node;\n    var i: i32 = 0;\n    while (i < index) : (i += 1) {\n        head = head.?.next;\n        if (head == null) return null;\n    }\n    return head;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#5","title":"5. \u00a0 \u67e5\u627e\u8282\u70b9","text":"

    \u904d\u5386\u94fe\u8868\uff0c\u67e5\u627e\u5176\u4e2d\u503c\u4e3a target \u7684\u8282\u70b9\uff0c\u8f93\u51fa\u8be5\u8282\u70b9\u5728\u94fe\u8868\u4e2d\u7684\u7d22\u5f15\u3002\u6b64\u8fc7\u7a0b\u4e5f\u5c5e\u4e8e\u7ebf\u6027\u67e5\u627e\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head->val == target)\n            return index;\n        head = head->next;\n        index++;\n    }\n    return -1;\n}\n
    linked_list.java
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -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) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\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 {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -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 {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n
    linked_list.js
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -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 {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -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) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n
    linked_list.rs
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\npub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {\n    if head.borrow().val == target {\n        return index;\n    };\n    if let Some(node) = &head.borrow_mut().next {\n        return find(node.clone(), target, index + 1);\n    }\n    return -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) {\n    int index = 0;\n    while (head) {\n        if (head->val == target)\n            return index;\n        head = head->next;\n        index++;\n    }\n    return -1;\n}\n
    linked_list.kt
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h.value == target) return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n
    linked_list.rb
    ### \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\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 {\n    var head = node;\n    var index: i32 = 0;\n    while (head != null) {\n        if (head.?.val == target) return index;\n        head = head.?.next;\n        index += 1;\n    }\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#422-vs","title":"4.2.2 \u00a0 \u6570\u7ec4 vs. \u94fe\u8868","text":"

    \u8868 4-1 \u603b\u7ed3\u4e86\u6570\u7ec4\u548c\u94fe\u8868\u7684\u5404\u9879\u7279\u70b9\u5e76\u5bf9\u6bd4\u4e86\u64cd\u4f5c\u6548\u7387\u3002\u7531\u4e8e\u5b83\u4eec\u91c7\u7528\u4e24\u79cd\u76f8\u53cd\u7684\u5b58\u50a8\u7b56\u7565\uff0c\u56e0\u6b64\u5404\u79cd\u6027\u8d28\u548c\u64cd\u4f5c\u6548\u7387\u4e5f\u5448\u73b0\u5bf9\u7acb\u7684\u7279\u70b9\u3002

    \u8868 4-1 \u00a0 \u6570\u7ec4\u4e0e\u94fe\u8868\u7684\u6548\u7387\u5bf9\u6bd4

    \u6570\u7ec4 \u94fe\u8868 \u5b58\u50a8\u65b9\u5f0f \u8fde\u7eed\u5185\u5b58\u7a7a\u95f4 \u5206\u6563\u5185\u5b58\u7a7a\u95f4 \u5bb9\u91cf\u6269\u5c55 \u957f\u5ea6\u4e0d\u53ef\u53d8 \u53ef\u7075\u6d3b\u6269\u5c55 \u5185\u5b58\u6548\u7387 \u5143\u7d20\u5360\u7528\u5185\u5b58\u5c11\u3001\u4f46\u53ef\u80fd\u6d6a\u8d39\u7a7a\u95f4 \u5143\u7d20\u5360\u7528\u5185\u5b58\u591a \u8bbf\u95ee\u5143\u7d20 \\(O(1)\\) \\(O(n)\\) \u6dfb\u52a0\u5143\u7d20 \\(O(n)\\) \\(O(1)\\) \u5220\u9664\u5143\u7d20 \\(O(n)\\) \\(O(1)\\)"},{"location":"chapter_array_and_linkedlist/linked_list/#423","title":"4.2.3 \u00a0 \u5e38\u89c1\u94fe\u8868\u7c7b\u578b","text":"

    \u5982\u56fe 4-8 \u6240\u793a\uff0c\u5e38\u89c1\u7684\u94fe\u8868\u7c7b\u578b\u5305\u62ec\u4e09\u79cd\u3002

    • \u5355\u5411\u94fe\u8868\uff1a\u5373\u524d\u9762\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\u5f15\u7528\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\u79f0\u4e3a\u5c3e\u8282\u70b9\uff0c\u5c3e\u8282\u70b9\u6307\u5411\u7a7a None \u3002
    • \u73af\u5f62\u94fe\u8868\uff1a\u5982\u679c\u6211\u4eec\u4ee4\u5355\u5411\u94fe\u8868\u7684\u5c3e\u8282\u70b9\u6307\u5411\u5934\u8282\u70b9\uff08\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\uff1a\u4e0e\u5355\u5411\u94fe\u8868\u76f8\u6bd4\uff0c\u53cc\u5411\u94fe\u8868\u8bb0\u5f55\u4e86\u4e24\u4e2a\u65b9\u5411\u7684\u5f15\u7528\u3002\u53cc\u5411\u94fe\u8868\u7684\u8282\u70b9\u5b9a\u4e49\u540c\u65f6\u5305\u542b\u6307\u5411\u540e\u7ee7\u8282\u70b9\uff08\u4e0b\u4e00\u4e2a\u8282\u70b9\uff09\u548c\u524d\u9a71\u8282\u70b9\uff08\u4e0a\u4e00\u4e2a\u8282\u70b9\uff09\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class ListNode:\n    \"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # \u8282\u70b9\u503c\n        self.next: ListNode | None = None  # \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n        self.prev: ListNode | None = None  # \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\n    int val;         // \u8282\u70b9\u503c\n    ListNode *next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n    ListNode *prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // \u6784\u9020\u51fd\u6570\n};\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    int val;        // \u8282\u70b9\u503c\n    ListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    ListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n    ListNode(int x) { val = x; }  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode(int x) {  // \u6784\u9020\u51fd\u6570\n    int val = x;    // \u8282\u70b9\u503c\n    ListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    ListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype DoublyListNode struct {\n    Val  int             // \u8282\u70b9\u503c\n    Next *DoublyListNode // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n    Prev *DoublyListNode // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n}\n\n// NewDoublyListNode \u521d\u59cb\u5316\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    var val: Int // \u8282\u70b9\u503c\n    var next: ListNode? // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    var prev: ListNode? // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n\n    init(x: Int) { // \u6784\u9020\u51fd\u6570\n        val = x\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // \u8282\u70b9\u503c\n        this.next = next  ===  undefined ? null : next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n        this.prev = prev  ===  undefined ? null : prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // \u8282\u70b9\u503c\n        this.next = next  ===  undefined ? null : next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n        this.prev = prev  ===  undefined ? null : prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    int val;        // \u8282\u70b9\u503c\n    ListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    ListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n    ListNode(this.val, [this.next, this.prev]);  // \u6784\u9020\u51fd\u6570\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\u578b */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // \u8282\u70b9\u503c\n    next: Option<Rc<RefCell<ListNode>>>, // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n    prev: Option<Rc<RefCell<ListNode>>>, // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nimpl ListNode {\n    fn new(val: i32) -> Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct ListNode {\n    int val;               // \u8282\u70b9\u503c\n    struct ListNode *next; // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n    struct ListNode *prev; // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n} ListNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node->val = val;\n    node->next = NULL;\n    node->prev = NULL;\n    return node;\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\n// \u6784\u9020\u65b9\u6cd5\nclass ListNode(x: Int) {\n    val _val: Int = x           // \u8282\u70b9\u503c\n    val next: ListNode? = null  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    val prev: ListNode? = null  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n}\n
    # \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\nclass ListNode\n  attr_accessor :val    # \u8282\u70b9\u503c\n  attr_accessor :next   # \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n  attr_accessor :prev   # \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\npub fn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = 0, // \u8282\u70b9\u503c\n        next: ?*Self = null, // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n        prev: ?*Self = null, // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n\n        // \u6784\u9020\u51fd\u6570\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n            self.prev = null;\n        }\n    };\n}\n

    \u56fe 4-8 \u00a0 \u5e38\u89c1\u94fe\u8868\u79cd\u7c7b

    "},{"location":"chapter_array_and_linkedlist/linked_list/#424","title":"4.2.4 \u00a0 \u94fe\u8868\u5178\u578b\u5e94\u7528","text":"

    \u5355\u5411\u94fe\u8868\u901a\u5e38\u7528\u4e8e\u5b9e\u73b0\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u548c\u56fe\u7b49\u6570\u636e\u7ed3\u6784\u3002

    • \u6808\u4e0e\u961f\u5217\uff1a\u5f53\u63d2\u5165\u548c\u5220\u9664\u64cd\u4f5c\u90fd\u5728\u94fe\u8868\u7684\u4e00\u7aef\u8fdb\u884c\u65f6\uff0c\u5b83\u8868\u73b0\u51fa\u5148\u8fdb\u540e\u51fa\u7684\u7279\u6027\uff0c\u5bf9\u5e94\u6808\uff1b\u5f53\u63d2\u5165\u64cd\u4f5c\u5728\u94fe\u8868\u7684\u4e00\u7aef\u8fdb\u884c\uff0c\u5220\u9664\u64cd\u4f5c\u5728\u94fe\u8868\u7684\u53e6\u4e00\u7aef\u8fdb\u884c\uff0c\u5b83\u8868\u73b0\u51fa\u5148\u8fdb\u5148\u51fa\u7684\u7279\u6027\uff0c\u5bf9\u5e94\u961f\u5217\u3002
    • \u54c8\u5e0c\u8868\uff1a\u94fe\u5f0f\u5730\u5740\u662f\u89e3\u51b3\u54c8\u5e0c\u51b2\u7a81\u7684\u4e3b\u6d41\u65b9\u6848\u4e4b\u4e00\uff0c\u5728\u8be5\u65b9\u6848\u4e2d\uff0c\u6240\u6709\u51b2\u7a81\u7684\u5143\u7d20\u90fd\u4f1a\u88ab\u653e\u5230\u4e00\u4e2a\u94fe\u8868\u4e2d\u3002
    • \u56fe\uff1a\u90bb\u63a5\u8868\u662f\u8868\u793a\u56fe\u7684\u4e00\u79cd\u5e38\u7528\u65b9\u5f0f\uff0c\u5176\u4e2d\u56fe\u7684\u6bcf\u4e2a\u9876\u70b9\u90fd\u4e0e\u4e00\u4e2a\u94fe\u8868\u76f8\u5173\u8054\uff0c\u94fe\u8868\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\u90fd\u4ee3\u8868\u4e0e\u8be5\u9876\u70b9\u76f8\u8fde\u7684\u5176\u4ed6\u9876\u70b9\u3002

    \u53cc\u5411\u94fe\u8868\u5e38\u7528\u4e8e\u9700\u8981\u5feb\u901f\u67e5\u627e\u524d\u4e00\u4e2a\u548c\u540e\u4e00\u4e2a\u5143\u7d20\u7684\u573a\u666f\u3002

    • \u9ad8\u7ea7\u6570\u636e\u7ed3\u6784\uff1a\u6bd4\u5982\u5728\u7ea2\u9ed1\u6811\u3001B \u6811\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u8bbf\u95ee\u8282\u70b9\u7684\u7236\u8282\u70b9\uff0c\u8fd9\u53ef\u4ee5\u901a\u8fc7\u5728\u8282\u70b9\u4e2d\u4fdd\u5b58\u4e00\u4e2a\u6307\u5411\u7236\u8282\u70b9\u7684\u5f15\u7528\u6765\u5b9e\u73b0\uff0c\u7c7b\u4f3c\u4e8e\u53cc\u5411\u94fe\u8868\u3002
    • \u6d4f\u89c8\u5668\u5386\u53f2\uff1a\u5728\u7f51\u9875\u6d4f\u89c8\u5668\u4e2d\uff0c\u5f53\u7528\u6237\u70b9\u51fb\u524d\u8fdb\u6216\u540e\u9000\u6309\u94ae\u65f6\uff0c\u6d4f\u89c8\u5668\u9700\u8981\u77e5\u9053\u7528\u6237\u8bbf\u95ee\u8fc7\u7684\u524d\u4e00\u4e2a\u548c\u540e\u4e00\u4e2a\u7f51\u9875\u3002\u53cc\u5411\u94fe\u8868\u7684\u7279\u6027\u4f7f\u5f97\u8fd9\u79cd\u64cd\u4f5c\u53d8\u5f97\u7b80\u5355\u3002
    • LRU \u7b97\u6cd5\uff1a\u5728\u7f13\u5b58\u6dd8\u6c70\uff08LRU\uff09\u7b97\u6cd5\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u5feb\u901f\u627e\u5230\u6700\u8fd1\u6700\u5c11\u4f7f\u7528\u7684\u6570\u636e\uff0c\u4ee5\u53ca\u652f\u6301\u5feb\u901f\u6dfb\u52a0\u548c\u5220\u9664\u8282\u70b9\u3002\u8fd9\u65f6\u5019\u4f7f\u7528\u53cc\u5411\u94fe\u8868\u5c31\u975e\u5e38\u5408\u9002\u3002

    \u73af\u5f62\u94fe\u8868\u5e38\u7528\u4e8e\u9700\u8981\u5468\u671f\u6027\u64cd\u4f5c\u7684\u573a\u666f\uff0c\u6bd4\u5982\u64cd\u4f5c\u7cfb\u7edf\u7684\u8d44\u6e90\u8c03\u5ea6\u3002

    • \u65f6\u95f4\u7247\u8f6e\u8f6c\u8c03\u5ea6\u7b97\u6cd5\uff1a\u5728\u64cd\u4f5c\u7cfb\u7edf\u4e2d\uff0c\u65f6\u95f4\u7247\u8f6e\u8f6c\u8c03\u5ea6\u7b97\u6cd5\u662f\u4e00\u79cd\u5e38\u89c1\u7684 CPU \u8c03\u5ea6\u7b97\u6cd5\uff0c\u5b83\u9700\u8981\u5bf9\u4e00\u7ec4\u8fdb\u7a0b\u8fdb\u884c\u5faa\u73af\u3002\u6bcf\u4e2a\u8fdb\u7a0b\u88ab\u8d4b\u4e88\u4e00\u4e2a\u65f6\u95f4\u7247\uff0c\u5f53\u65f6\u95f4\u7247\u7528\u5b8c\u65f6\uff0cCPU \u5c06\u5207\u6362\u5230\u4e0b\u4e00\u4e2a\u8fdb\u7a0b\u3002\u8fd9\u79cd\u5faa\u73af\u64cd\u4f5c\u53ef\u4ee5\u901a\u8fc7\u73af\u5f62\u94fe\u8868\u6765\u5b9e\u73b0\u3002
    • \u6570\u636e\u7f13\u51b2\u533a\uff1a\u5728\u67d0\u4e9b\u6570\u636e\u7f13\u51b2\u533a\u7684\u5b9e\u73b0\u4e2d\uff0c\u4e5f\u53ef\u80fd\u4f1a\u4f7f\u7528\u73af\u5f62\u94fe\u8868\u3002\u6bd4\u5982\u5728\u97f3\u9891\u3001\u89c6\u9891\u64ad\u653e\u5668\u4e2d\uff0c\u6570\u636e\u6d41\u53ef\u80fd\u4f1a\u88ab\u5206\u6210\u591a\u4e2a\u7f13\u51b2\u5757\u5e76\u653e\u5165\u4e00\u4e2a\u73af\u5f62\u94fe\u8868\uff0c\u4ee5\u4fbf\u5b9e\u73b0\u65e0\u7f1d\u64ad\u653e\u3002
    "},{"location":"chapter_array_and_linkedlist/list/","title":"4.3 \u00a0 \u5217\u8868","text":"

    \u300c\u5217\u8868 list\u300d\u662f\u4e00\u4e2a\u62bd\u8c61\u7684\u6570\u636e\u7ed3\u6784\u6982\u5ff5\uff0c\u5b83\u8868\u793a\u5143\u7d20\u7684\u6709\u5e8f\u96c6\u5408\uff0c\u652f\u6301\u5143\u7d20\u8bbf\u95ee\u3001\u4fee\u6539\u3001\u6dfb\u52a0\u3001\u5220\u9664\u548c\u904d\u5386\u7b49\u64cd\u4f5c\uff0c\u65e0\u987b\u4f7f\u7528\u8005\u8003\u8651\u5bb9\u91cf\u9650\u5236\u7684\u95ee\u9898\u3002\u5217\u8868\u53ef\u4ee5\u57fa\u4e8e\u94fe\u8868\u6216\u6570\u7ec4\u5b9e\u73b0\u3002

    • \u94fe\u8868\u5929\u7136\u53ef\u4ee5\u770b\u4f5c\u4e00\u4e2a\u5217\u8868\uff0c\u5176\u652f\u6301\u5143\u7d20\u589e\u5220\u67e5\u6539\u64cd\u4f5c\uff0c\u5e76\u4e14\u53ef\u4ee5\u7075\u6d3b\u52a8\u6001\u6269\u5bb9\u3002
    • \u6570\u7ec4\u4e5f\u652f\u6301\u5143\u7d20\u589e\u5220\u67e5\u6539\uff0c\u4f46\u7531\u4e8e\u5176\u957f\u5ea6\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u53ea\u80fd\u770b\u4f5c\u4e00\u4e2a\u5177\u6709\u957f\u5ea6\u9650\u5236\u7684\u5217\u8868\u3002

    \u5f53\u4f7f\u7528\u6570\u7ec4\u5b9e\u73b0\u5217\u8868\u65f6\uff0c\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6027\u8d28\u4f1a\u5bfc\u81f4\u5217\u8868\u7684\u5b9e\u7528\u6027\u964d\u4f4e\u3002\u8fd9\u662f\u56e0\u4e3a\u6211\u4eec\u901a\u5e38\u65e0\u6cd5\u4e8b\u5148\u786e\u5b9a\u9700\u8981\u5b58\u50a8\u591a\u5c11\u6570\u636e\uff0c\u4ece\u800c\u96be\u4ee5\u9009\u62e9\u5408\u9002\u7684\u5217\u8868\u957f\u5ea6\u3002\u82e5\u957f\u5ea6\u8fc7\u5c0f\uff0c\u5219\u5f88\u53ef\u80fd\u65e0\u6cd5\u6ee1\u8db3\u4f7f\u7528\u9700\u6c42\uff1b\u82e5\u957f\u5ea6\u8fc7\u5927\uff0c\u5219\u4f1a\u9020\u6210\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u3002

    \u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u300c\u52a8\u6001\u6570\u7ec4 dynamic array\u300d\u6765\u5b9e\u73b0\u5217\u8868\u3002\u5b83\u7ee7\u627f\u4e86\u6570\u7ec4\u7684\u5404\u9879\u4f18\u70b9\uff0c\u5e76\u4e14\u53ef\u4ee5\u5728\u7a0b\u5e8f\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u8fdb\u884c\u52a8\u6001\u6269\u5bb9\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\u4e2d\u7684\u6807\u51c6\u5e93\u63d0\u4f9b\u7684\u5217\u8868\u662f\u57fa\u4e8e\u52a8\u6001\u6570\u7ec4\u5b9e\u73b0\u7684\uff0c\u4f8b\u5982 Python \u4e2d\u7684 list \u3001Java \u4e2d\u7684 ArrayList \u3001C++ \u4e2d\u7684 vector \u548c C# \u4e2d\u7684 List \u7b49\u3002\u5728\u63a5\u4e0b\u6765\u7684\u8ba8\u8bba\u4e2d\uff0c\u6211\u4eec\u5c06\u628a\u201c\u5217\u8868\u201d\u548c\u201c\u52a8\u6001\u6570\u7ec4\u201d\u89c6\u4e3a\u7b49\u540c\u7684\u6982\u5ff5\u3002

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

    \u6211\u4eec\u901a\u5e38\u4f7f\u7528\u201c\u65e0\u521d\u59cb\u503c\u201d\u548c\u201c\u6709\u521d\u59cb\u503c\u201d\u8fd9\u4e24\u79cd\u521d\u59cb\u5316\u65b9\u6cd5\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u521d\u59cb\u5316\u5217\u8868\n# \u65e0\u521d\u59cb\u503c\nnums1: list[int] = []\n# \u6709\u521d\u59cb\u503c\nnums: list[int] = [1, 3, 2, 5, 4]\n
    list.cpp
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u9700\u6ce8\u610f\uff0cC++ \u4e2d vector \u5373\u662f\u672c\u6587\u63cf\u8ff0\u7684 nums\n// \u65e0\u521d\u59cb\u503c\nvector<int> nums1;\n// \u6709\u521d\u59cb\u503c\nvector<int> nums = { 1, 3, 2, 5, 4 };\n
    list.java
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<Integer> nums1 = 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> nums = new ArrayList<>(Arrays.asList(numbers));\n
    list.cs
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<int> nums1 = [];\n// \u6709\u521d\u59cb\u503c\nint[] numbers = [1, 3, 2, 5, 4];\nList<int> nums = [.. numbers];\n
    list_test.go
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nnums1 := []int{}\n// \u6709\u521d\u59cb\u503c\nnums := []int{1, 3, 2, 5, 4}\n
    list.swift
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nlet nums1: [Int] = []\n// \u6709\u521d\u59cb\u503c\nvar nums = [1, 3, 2, 5, 4]\n
    list.js
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nconst nums1 = [];\n// \u6709\u521d\u59cb\u503c\nconst nums = [1, 3, 2, 5, 4];\n
    list.ts
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nconst nums1: number[] = [];\n// \u6709\u521d\u59cb\u503c\nconst nums: number[] = [1, 3, 2, 5, 4];\n
    list.dart
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<int> nums1 = [];\n// \u6709\u521d\u59cb\u503c\nList<int> nums = [1, 3, 2, 5, 4];\n
    list.rs
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nlet nums1: Vec<i32> = Vec::new();\n// \u6709\u521d\u59cb\u503c\nlet nums: Vec<i32> = vec![1, 3, 2, 5, 4];\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.kt
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nvar nums1 = listOf<Int>()\n// \u6709\u521d\u59cb\u503c\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n
    list.rb
    # \u521d\u59cb\u5316\u5217\u8868\n# \u65e0\u521d\u59cb\u503c\nnums1 = []\n# \u6709\u521d\u59cb\u503c\nnums = [1, 3, 2, 5, 4]\n
    list.zig
    // \u521d\u59cb\u5316\u5217\u8868\nvar nums = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nums.deinit();\ntry nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#2","title":"2. \u00a0 \u8bbf\u95ee\u5143\u7d20","text":"

    \u5217\u8868\u672c\u8d28\u4e0a\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u8bbf\u95ee\u5143\u7d20\nnum: int = nums[1]  # \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n# \u66f4\u65b0\u5143\u7d20\nnums[1] = 0    # \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.cpp
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.java
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = nums.get(1);  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums.set(1, 0);  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.cs
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list_test.go
    /* \u8bbf\u95ee\u5143\u7d20 */\nnum := nums[1]  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0     // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.swift
    /* \u8bbf\u95ee\u5143\u7d20 */\nlet num = nums[1] // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0 // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.js
    /* \u8bbf\u95ee\u5143\u7d20 */\nconst num = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.ts
    /* \u8bbf\u95ee\u5143\u7d20 */\nconst num: number = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.dart
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.rs
    /* \u8bbf\u95ee\u5143\u7d20 */\nlet num: i32 = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[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.kt
    /* \u8bbf\u95ee\u5143\u7d20 */\nval num = nums[1]       // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0             // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.rb
    # \u8bbf\u95ee\u5143\u7d20\nnum = nums[1] # \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n# \u66f4\u65b0\u5143\u7d20\nnums[1] = 0 # \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.zig
    // \u8bbf\u95ee\u5143\u7d20\nvar num = nums.items[1]; // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n// \u66f4\u65b0\u5143\u7d20\nnums.items[1] = 0; // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#3","title":"3. \u00a0 \u63d2\u5165\u4e0e\u5220\u9664\u5143\u7d20","text":"

    \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

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

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#4","title":"4. \u00a0 \u904d\u5386\u5217\u8868","text":"

    \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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\nfor num in nums:\n    count += num\n
    list.cpp
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < nums.size(); i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n
    list.java
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\nfor (int num : nums) {\n    count += num;\n}\n
    list.cs
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < nums.Count; i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n
    list_test.go
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\ncount := 0\nfor i := 0; i < len(nums); i++ {\n    count += nums[i]\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n
    list.swift
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0\nfor num in nums {\n    count += num\n}\n
    list.js
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nlet count = 0;\nfor (let i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n
    list.ts
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nlet count = 0;\nfor (let i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n
    list.dart
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (var i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n
    list.rs
    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\n_count = 0;\nfor num in &nums {\n    _count += num;\n}\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.kt
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\nfor (num in nums) {\n    count += num\n}\n
    list.rb
    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\ncount = 0\nfor num in nums\n    count += num\nend\n
    list.zig
    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\nvar count: i32 = 0;\nvar i: i32 = 0;\nwhile (i < nums.items.len) : (i += 1) {\n    count += nums[i];\n}\n\n// \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\ncount = 0;\nfor (nums.items) |num| {\n    count += num;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#5","title":"5. \u00a0 \u62fc\u63a5\u5217\u8868","text":"

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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.cpp
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nvector<int> nums1 = { 6, 8, 7, 10, 9 };\n// \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n
    list.java
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.cs
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<int> nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list_test.go
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.swift
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.js
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.ts
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.dart
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<int> nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.rs
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nlet nums1: Vec<i32> = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.kt
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.rb
    # \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n
    list.zig
    // \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nvar nums1 = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nums1.deinit();\ntry nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });\ntry nums.insertSlice(nums.items.len, nums1.items); // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#6","title":"6. \u00a0 \u6392\u5e8f\u5217\u8868","text":"

    \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\u67e5\u7684\u201c\u4e8c\u5206\u67e5\u627e\u201d\u548c\u201c\u53cc\u6307\u9488\u201d\u7b97\u6cd5\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u6392\u5e8f\u5217\u8868\nnums.sort()  # \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.cpp
    /* \u6392\u5e8f\u5217\u8868 */\nsort(nums.begin(), nums.end());  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.java
    /* \u6392\u5e8f\u5217\u8868 */\nCollections.sort(nums);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.cs
    /* \u6392\u5e8f\u5217\u8868 */\nnums.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(nums)  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.swift
    /* \u6392\u5e8f\u5217\u8868 */\nnums.sort() // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.js
    /* \u6392\u5e8f\u5217\u8868 */\nnums.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 */\nnums.sort((a, b) => a - b);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.dart
    /* \u6392\u5e8f\u5217\u8868 */\nnums.sort(); // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.rs
    /* \u6392\u5e8f\u5217\u8868 */\nnums.sort(); // \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.kt
    /* \u6392\u5e8f\u5217\u8868 */\nnums.sort() // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.rb
    # \u6392\u5e8f\u5217\u8868\nnums = nums.sort { |a, b| a <=> b } # \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, nums.items, {}, comptime std.sort.asc(i32));\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#432","title":"4.3.2 \u00a0 \u5217\u8868\u5b9e\u73b0","text":"

    \u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\u5185\u7f6e\u4e86\u5217\u8868\uff0c\u4f8b\u5982 Java\u3001C++\u3001Python \u7b49\u3002\u5b83\u4eec\u7684\u5b9e\u73b0\u6bd4\u8f83\u590d\u6742\uff0c\u5404\u4e2a\u53c2\u6570\u7684\u8bbe\u5b9a\u4e5f\u975e\u5e38\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

    \u4e3a\u4e86\u52a0\u6df1\u5bf9\u5217\u8868\u5de5\u4f5c\u539f\u7406\u7684\u7406\u89e3\uff0c\u6211\u4eec\u5c1d\u8bd5\u5b9e\u73b0\u4e00\u4e2a\u7b80\u6613\u7248\u5217\u8868\uff0c\u5305\u62ec\u4ee5\u4e0b\u4e09\u4e2a\u91cd\u70b9\u8bbe\u8ba1\u3002

    • \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\u82e5\u63d2\u5165\u5143\u7d20\u65f6\u5217\u8868\u5bb9\u91cf\u5df2\u6ee1\uff0c\u5219\u9700\u8981\u8fdb\u884c\u6269\u5bb9\u3002\u5148\u6839\u636e\u6269\u5bb9\u500d\u6570\u521b\u5efa\u4e00\u4e2a\u66f4\u5927\u7684\u6570\u7ec4\uff0c\u518d\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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_list.py
    class MyList:\n    \"\"\"\u5217\u8868\u7c7b\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._capacity: int = 10  # \u5217\u8868\u5bb9\u91cf\n        self._arr: list[int] = [0] * self._capacity  # \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        self._size: int = 0  # \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        self._extend_ratio: int = 2  # \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\"\"\"\n        return self._size\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u5217\u8868\u5bb9\u91cf\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -> int:\n        \"\"\"\u8bbf\u95ee\u5143\u7d20\"\"\"\n        # \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"\u66f4\u65b0\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"\u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\"\"\"\n        # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"\u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self._size += 1\n\n    def remove(self, index: int) -> int:\n        \"\"\"\u5220\u9664\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        num = self._arr[index]\n        # \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self._size -= 1\n        # \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n\n    def extend_capacity(self):\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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        self._capacity = len(self._arr)\n\n    def to_array(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u6709\u6548\u957f\u5ea6\u7684\u5217\u8868\"\"\"\n        return self._arr[: self._size]\n
    my_list.cpp
    /* \u5217\u8868\u7c7b */\nclass MyList {\n  private:\n    int *arr;             // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    int arrCapacity = 10; // \u5217\u8868\u5bb9\u91cf\n    int arrSize = 0;      // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    int extendRatio = 2;   // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    int size() {\n        return arrSize;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    int get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    void set(int index, int num) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    void add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    void insert(int index, int num) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size() == capacity())\n            extendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = size() - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    int remove(int index) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    void extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // \u91ca\u653e\u5185\u5b58\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Vector \u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> vec(size());\n        for (int i = 0; i < size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n
    my_list.java
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private int[] arr; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private int capacity = 10; // \u5217\u8868\u5bb9\u91cf\n    private int size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private int extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\n    public int size() {\n        return size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public int get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public void set(int index, int num) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public void add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public void insert(int index, int num) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = size - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public int remove(int index) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public 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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        capacity = arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public int[] toArray() {\n        int size = size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] arr = new int[size];\n        for (int i = 0; i < size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.cs
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private int[] arr;           // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private int arrCapacity = 10;    // \u5217\u8868\u5bb9\u91cf\n    private int arrSize = 0;         // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private readonly int extendRatio = 2;  // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    public int Size() {\n        return arrSize;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public int Get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public void Set(int index, int num) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public void Add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public void Insert(int index, int num) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = arrSize - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public int Remove(int index) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public void ExtendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a arrCapacity * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        arrCapacity = arr.Length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] arr = new int[arrSize];\n        for (int i = 0; i < arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.go
    /* \u5217\u8868\u7c7b */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newMyList() *myList {\n    return &myList{\n        arrCapacity: 10,              // \u5217\u8868\u5bb9\u91cf\n        arr:         make([]int, 10), // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        arrSize:     0,               // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        extendRatio: 2,               // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n    }\n}\n\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/*  \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nfunc (l *myList) get(index int) int {\n    // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    return l.arr[index]\n}\n\n/* \u66f4\u65b0\u5143\u7d20 */\nfunc (l *myList) set(num, index int) {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    l.arr[index] = num\n}\n\n/* \u5728\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\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize++\n}\n\n/* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nfunc (l *myList) insert(num, index int) {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for j := l.arrSize - 1; j >= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize++\n}\n\n/* \u5220\u9664\u5143\u7d20 */\nfunc (l *myList) remove(index int) int {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    num := l.arr[index]\n    // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for j := index; j < l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize--\n    // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    return num\n}\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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    l.arrCapacity = len(l.arr)\n}\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\n    return l.arr[:l.arrSize]\n}\n
    my_list.swift
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private var arr: [Int] // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private var _capacity: Int // \u5217\u8868\u5bb9\u91cf\n    private var _size: Int // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private let extendRatio: Int // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    func size() -> Int {\n        _size\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    func capacity() -> Int {\n        _capacity\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    func get(index: Int) -> Int {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u9519\u8bef\uff0c\u4e0b\u540c\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        return arr[index]\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    func set(index: Int, num: Int) {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        arr[index] = num\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    func add(num: Int) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size += 1\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    func insert(index: Int, num: Int) {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in (index ..< size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size += 1\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    @discardableResult\n    func remove(index: Int) -> Int {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        let num = arr[index]\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in index ..< (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size -= 1\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    func extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        _capacity = arr.count\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    func toArray() -> [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n
    my_list.js
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    #arr = 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\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    #extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    size() {\n        return this.#size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    get(index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        return this.#arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    set(index, num) {\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        this.#arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    add(num) {\n        // \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    insert(index, num) {\n        if (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\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (let j = this.#size - 1; j >= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    remove(index) {\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        let num = this.#arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (let j = index; j < this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.#size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        this.#capacity = this.#arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    toArray() {\n        let size = this.size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(size);\n        for (let i = 0; i < size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.ts
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private arr: Array<number>; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private _capacity: number = 10; // \u5217\u8868\u5bb9\u91cf\n    private _size: number = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private extendRatio: number = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    public size(): number {\n        return this._size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public get(index: number): number {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        return this.arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public set(index: number, num: number): void {\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        this.arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public add(num: number): void {\n        // \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\n        if (this._size === this._capacity) this.extendCapacity();\n        // \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public insert(index: number, num: number): void {\n        if (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\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (let j = this._size - 1; j >= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public remove(index: number): number {\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        let num = this.arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (let j = index; j < this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this._size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public extendCapacity(): void {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        this._capacity = this.arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public toArray(): number[] {\n        let size = this.size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(size);\n        for (let i = 0; i < size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.dart
    /* \u5217\u8868\u7c7b */\nclass MyList {\n  late List<int> _arr; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n  int _capacity = 10; // \u5217\u8868\u5bb9\u91cf\n  int _size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n  int _extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n  int size() => _size;\n\n  /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n  int capacity() => _capacity;\n\n  /* \u8bbf\u95ee\u5143\u7d20 */\n  int get(int index) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    return _arr[index];\n  }\n\n  /* \u66f4\u65b0\u5143\u7d20 */\n  void set(int index, int _num) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    _arr[index] = _num;\n  }\n\n  /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n  void add(int _num) {\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size++;\n  }\n\n  /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n  void insert(int index, int _num) {\n    if (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\n    if (_size == _capacity) extendCapacity();\n    // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for (var j = _size - 1; j >= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size++;\n  }\n\n  /* \u5220\u9664\u5143\u7d20 */\n  int remove(int index) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    int _num = _arr[index];\n    // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (var j = index; j < _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size--;\n    // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    return _num;\n  }\n\n  /* \u5217\u8868\u6269\u5bb9 */\n  void extendCapacity() {\n    // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 _extendRatio \u500d\u7684\u65b0\u6570\u7ec4\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // \u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    List.copyRange(_newNums, 0, _arr);\n    // \u66f4\u65b0 _arr \u7684\u5f15\u7528\n    _arr = _newNums;\n    // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    _capacity = _arr.length;\n  }\n\n  /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n  List<int> toArray() {\n    List<int> arr = [];\n    for (var i = 0; i < _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n
    my_list.rs
    /* \u5217\u8868\u7c7b */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec<i32>,       // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    capacity: usize,     // \u5217\u8868\u5bb9\u91cf\n    size: usize,         // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    extend_ratio: usize, // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(capacity: usize) -> Self {\n        let mut vec = Vec::new();\n        vec.resize(capacity, 0);\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    pub fn size(&self) -> usize {\n        return self.size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    pub fn capacity(&self) -> usize {\n        return self.capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    pub fn get(&self, index: usize) -> i32 {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if index >= self.size {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        return self.arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    pub fn set(&mut self, index: usize, num: i32) {\n        if index >= self.size {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    pub fn add(&mut self, num: i32) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size += 1;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    pub fn insert(&mut self, index: usize, num: i32) {\n        if index >= self.size() {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size += 1;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    pub fn remove(&mut self, index: usize) -> i32 {\n        if index >= self.size() {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        let num = self.arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in (index..self.size - 1) {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size -= 1;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    pub fn extend_capacity(&mut self) {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        self.capacity = new_capacity;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    pub fn to_array(&mut self) -> Vec<i32> {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n
    my_list.c
    /* \u5217\u8868\u7c7b */\ntypedef struct {\n    int *arr;        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    int capacity;    // \u5217\u8868\u5bb9\u91cf\n    int size;        // \u5217\u8868\u5927\u5c0f\n    int extendRatio; // \u5217\u8868\u6bcf\u6b21\u6269\u5bb9\u7684\u500d\u6570\n} MyList;\n\n/* \u6784\u9020\u51fd\u6570 */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums->capacity = 10;\n    nums->arr = malloc(sizeof(int) * nums->capacity);\n    nums->size = 0;\n    nums->extendRatio = 2;\n    return nums;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delMyList(MyList *nums) {\n    free(nums->arr);\n    free(nums);\n}\n\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6 */\nint size(MyList *nums) {\n    return nums->size;\n}\n\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity(MyList *nums) {\n    return nums->capacity;\n}\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(MyList *nums, int index) {\n    assert(index >= 0 && index < nums->size);\n    return nums->arr[index];\n}\n\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(MyList *nums, int index, int num) {\n    assert(index >= 0 && index < nums->size);\n    nums->arr[index] = num;\n}\n\n/* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // \u6269\u5bb9\n    }\n    nums->arr[size(nums)] = num;\n    nums->size++;\n}\n\n/* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index >= 0 && index < size(nums));\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // \u6269\u5bb9\n    }\n    for (int i = size(nums); i > index; --i) {\n        nums->arr[i] = nums->arr[i - 1];\n    }\n    nums->arr[index] = num;\n    nums->size++;\n}\n\n/* \u5220\u9664\u5143\u7d20 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nint removeItem(MyList *nums, int index) {\n    assert(index >= 0 && index < size(nums));\n    int num = nums->arr[index];\n    for (int i = index; i < size(nums) - 1; i++) {\n        nums->arr[i] = nums->arr[i + 1];\n    }\n    nums->size--;\n    return num;\n}\n\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity(MyList *nums) {\n    // \u5148\u5206\u914d\u7a7a\u95f4\n    int newCapacity = capacity(nums) * nums->extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums->arr;\n\n    // \u62f7\u8d1d\u65e7\u6570\u636e\u5230\u65b0\u6570\u636e\n    for (int i = 0; i < size(nums); i++)\n        extend[i] = nums->arr[i];\n\n    // \u91ca\u653e\u65e7\u6570\u636e\n    free(temp);\n\n    // \u66f4\u65b0\u65b0\u6570\u636e\n    nums->arr = extend;\n    nums->capacity = newCapacity;\n}\n\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Array \u7528\u4e8e\u6253\u5370 */\nint *toArray(MyList *nums) {\n    return nums->arr;\n}\n
    my_list.kt
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private var capacity = 10 // \u5217\u8868\u5bb9\u91cf\n    private var size = 0 // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private var extendRatio = 2 // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\n    fun size(): Int {\n        return size\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    fun get(index: Int): Int {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException()\n        return arr[index]\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    fun set(index: Int, num: Int) {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        arr[index] = num\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    fun add(num: Int) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    fun insert(index: Int, num: Int) {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity()\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    fun remove(index: Int): Int {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        val num: Int = arr[index]\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (j in index..<size - 1)\n            arr[j] = arr[j + 1]\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size--\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    fun extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = arr.copyOf(capacity() * extendRatio)\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        capacity = arr.size\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    fun toArray(): IntArray {\n        val size = size()\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val arr = IntArray(size)\n        for (i in 0..<size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n
    my_list.rb
    ### \u5217\u8868\u7c7b ###\nclass MyList\n  attr_reader :size       # \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n  attr_reader :capacity   # \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\n\n  ### \u6784\u9020\u65b9\u6cd5 ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new capacity\n  end\n\n  ### \u8bbf\u95ee\u5143\u7d20 ###\n  def get(index)\n    # \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    @arr[index]\n  end\n\n  ### \u8bbf\u95ee\u5143\u7d20 ###\n  def set(index, num)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    @arr[index] = num\n  end\n\n  ### \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 ###\n  def add(num)\n    # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size += 1\n  end\n\n  ### \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 ###\n  def insert(index, num)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n\n    # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    extend_capacity if size == capacity\n\n    # \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j] \n    end\n    @arr[index] = num\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size += 1\n  end\n\n  ### \u5220\u9664\u5143\u7d20 ###\n  def remove(index)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    num = @arr[index]\n\n    # \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size -= 1\n\n    # \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    num\n  end\n\n  ### \u5217\u8868\u6269\u5bb9 ###\n  def extend_capacity\n    # \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    @capacity = arr.length\n  end\n\n  ### \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 ###\n  def to_array\n    sz = size\n    # \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    arr = Array.new sz\n    for i in 0...sz\n      arr[i] = get i\n    end\n    arr\n  end\nend\n
    my_list.zig
    // \u5217\u8868\u7c7b\nfn MyList(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        arr: []T = undefined,                        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        arrCapacity: usize = 10,                     // \u5217\u8868\u5bb9\u91cf\n        numSize: usize = 0,                           // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        extendRatio: usize = 2,                       // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined, // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u5217\u8868\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);\n            @memset(self.arr, @as(T, 0));\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        pub fn size(self: *Self) usize {\n            return self.numSize;\n        }\n\n        // \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\n        pub fn capacity(self: *Self) usize {\n            return self.arrCapacity;\n        }\n\n        // \u8bbf\u95ee\u5143\u7d20\n        pub fn get(self: *Self, index: usize) T {\n            // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            return self.arr[index];\n        }  \n\n        // \u66f4\u65b0\u5143\u7d20\n        pub fn set(self: *Self, index: usize, num: T) void {\n            // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            self.arr[index] = num;\n        }  \n\n        // \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\n        pub fn add(self: *Self, num: T) !void {\n            // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n            if (self.size() == self.capacity()) try self.extendCapacity();\n            self.arr[self.size()] = num;\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize += 1;\n        }  \n\n        // \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\n        pub fn insert(self: *Self, index: usize, num: T) !void {\n            if (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\n            if (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\n            var j = self.size() - 1;\n            while (j >= index) : (j -= 1) {\n                self.arr[j + 1] = self.arr[j];\n            }\n            self.arr[index] = num;\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize += 1;\n        }\n\n        // \u5220\u9664\u5143\u7d20\n        pub fn remove(self: *Self, index: usize) T {\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            var num = self.arr[index];\n            // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n            var j = index;\n            while (j < self.size() - 1) : (j += 1) {\n                self.arr[j] = self.arr[j + 1];\n            }\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize -= 1;\n            // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n            return num;\n        }\n\n        // \u5217\u8868\u6269\u5bb9\n        pub fn extendCapacity(self: *Self) !void {\n            // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n            var newCapacity = self.capacity() * self.extendRatio;\n            var 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\n            std.mem.copy(T, extend, self.arr);\n            self.arr = extend;\n            // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n            self.arrCapacity = newCapacity;\n        }\n\n        // \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n            var arr = try self.mem_allocator.alloc(T, self.size());\n           @memset(arr, @as(T, 0));\n            for (arr, 0..) |*num, i| {\n                num.* = self.get(i);\n            }\n            return arr;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/","title":"4.4 \u00a0 \u5185\u5b58\u4e0e\u7f13\u5b58 *","text":"

    \u5728\u672c\u7ae0\u7684\u524d\u4e24\u8282\u4e2d\uff0c\u6211\u4eec\u63a2\u8ba8\u4e86\u6570\u7ec4\u548c\u94fe\u8868\u8fd9\u4e24\u79cd\u57fa\u7840\u4e14\u91cd\u8981\u7684\u6570\u636e\u7ed3\u6784\uff0c\u5b83\u4eec\u5206\u522b\u4ee3\u8868\u4e86\u201c\u8fde\u7eed\u5b58\u50a8\u201d\u548c\u201c\u5206\u6563\u5b58\u50a8\u201d\u4e24\u79cd\u7269\u7406\u7ed3\u6784\u3002

    \u5b9e\u9645\u4e0a\uff0c\u7269\u7406\u7ed3\u6784\u5728\u5f88\u5927\u7a0b\u5ea6\u4e0a\u51b3\u5b9a\u4e86\u7a0b\u5e8f\u5bf9\u5185\u5b58\u548c\u7f13\u5b58\u7684\u4f7f\u7528\u6548\u7387\uff0c\u8fdb\u800c\u5f71\u54cd\u7b97\u6cd5\u7a0b\u5e8f\u7684\u6574\u4f53\u6027\u80fd\u3002

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441","title":"4.4.1 \u00a0 \u8ba1\u7b97\u673a\u5b58\u50a8\u8bbe\u5907","text":"

    \u8ba1\u7b97\u673a\u4e2d\u5305\u62ec\u4e09\u79cd\u7c7b\u578b\u7684\u5b58\u50a8\u8bbe\u5907\uff1a\u300c\u786c\u76d8 hard disk\u300d\u3001\u300c\u5185\u5b58 random-access memory, RAM\u300d\u3001\u300c\u7f13\u5b58 cache memory\u300d\u3002\u8868 4-2 \u5c55\u793a\u4e86\u5b83\u4eec\u5728\u8ba1\u7b97\u673a\u7cfb\u7edf\u4e2d\u7684\u4e0d\u540c\u89d2\u8272\u548c\u6027\u80fd\u7279\u70b9\u3002

    \u8868 4-2 \u00a0 \u8ba1\u7b97\u673a\u7684\u5b58\u50a8\u8bbe\u5907

    \u786c\u76d8 \u5185\u5b58 \u7f13\u5b58 \u7528\u9014 \u957f\u671f\u5b58\u50a8\u6570\u636e\uff0c\u5305\u62ec\u64cd\u4f5c\u7cfb\u7edf\u3001\u7a0b\u5e8f\u3001\u6587\u4ef6\u7b49 \u4e34\u65f6\u5b58\u50a8\u5f53\u524d\u8fd0\u884c\u7684\u7a0b\u5e8f\u548c\u6b63\u5728\u5904\u7406\u7684\u6570\u636e \u5b58\u50a8\u7ecf\u5e38\u8bbf\u95ee\u7684\u6570\u636e\u548c\u6307\u4ee4\uff0c\u51cf\u5c11 CPU \u8bbf\u95ee\u5185\u5b58\u7684\u6b21\u6570 \u6613\u5931\u6027 \u65ad\u7535\u540e\u6570\u636e\u4e0d\u4f1a\u4e22\u5931 \u65ad\u7535\u540e\u6570\u636e\u4f1a\u4e22\u5931 \u65ad\u7535\u540e\u6570\u636e\u4f1a\u4e22\u5931 \u5bb9\u91cf \u8f83\u5927\uff0cTB \u7ea7\u522b \u8f83\u5c0f\uff0cGB \u7ea7\u522b \u975e\u5e38\u5c0f\uff0cMB \u7ea7\u522b \u901f\u5ea6 \u8f83\u6162\uff0c\u51e0\u767e\u5230\u51e0\u5343 MB/s \u8f83\u5feb\uff0c\u51e0\u5341 GB/s \u975e\u5e38\u5feb\uff0c\u51e0\u5341\u5230\u51e0\u767e GB/s \u4ef7\u683c \u8f83\u4fbf\u5b9c\uff0c\u51e0\u6bdb\u5230\u51e0\u5143 / GB \u8f83\u8d35\uff0c\u51e0\u5341\u5230\u51e0\u767e\u5143 / GB \u975e\u5e38\u8d35\uff0c\u968f CPU \u6253\u5305\u8ba1\u4ef7

    \u6211\u4eec\u53ef\u4ee5\u5c06\u8ba1\u7b97\u673a\u5b58\u50a8\u7cfb\u7edf\u60f3\u8c61\u4e3a\u56fe 4-9 \u6240\u793a\u7684\u91d1\u5b57\u5854\u7ed3\u6784\u3002\u8d8a\u9760\u8fd1\u91d1\u5b57\u5854\u9876\u7aef\u7684\u5b58\u50a8\u8bbe\u5907\u7684\u901f\u5ea6\u8d8a\u5feb\u3001\u5bb9\u91cf\u8d8a\u5c0f\u3001\u6210\u672c\u8d8a\u9ad8\u3002\u8fd9\u79cd\u591a\u5c42\u7ea7\u7684\u8bbe\u8ba1\u5e76\u975e\u5076\u7136\uff0c\u800c\u662f\u8ba1\u7b97\u673a\u79d1\u5b66\u5bb6\u548c\u5de5\u7a0b\u5e08\u4eec\u7ecf\u8fc7\u6df1\u601d\u719f\u8651\u7684\u7ed3\u679c\u3002

    • \u786c\u76d8\u96be\u4ee5\u88ab\u5185\u5b58\u53d6\u4ee3\u3002\u9996\u5148\uff0c\u5185\u5b58\u4e2d\u7684\u6570\u636e\u5728\u65ad\u7535\u540e\u4f1a\u4e22\u5931\uff0c\u56e0\u6b64\u5b83\u4e0d\u9002\u5408\u957f\u671f\u5b58\u50a8\u6570\u636e\uff1b\u5176\u6b21\uff0c\u5185\u5b58\u7684\u6210\u672c\u662f\u786c\u76d8\u7684\u51e0\u5341\u500d\uff0c\u8fd9\u4f7f\u5f97\u5b83\u96be\u4ee5\u5728\u6d88\u8d39\u8005\u5e02\u573a\u666e\u53ca\u3002
    • \u7f13\u5b58\u7684\u5927\u5bb9\u91cf\u548c\u9ad8\u901f\u5ea6\u96be\u4ee5\u517c\u5f97\u3002\u968f\u7740 L1\u3001L2\u3001L3 \u7f13\u5b58\u7684\u5bb9\u91cf\u9010\u6b65\u589e\u5927\uff0c\u5176\u7269\u7406\u5c3a\u5bf8\u4f1a\u53d8\u5927\uff0c\u4e0e CPU \u6838\u5fc3\u4e4b\u95f4\u7684\u7269\u7406\u8ddd\u79bb\u4f1a\u53d8\u8fdc\uff0c\u4ece\u800c\u5bfc\u81f4\u6570\u636e\u4f20\u8f93\u65f6\u95f4\u589e\u52a0\uff0c\u5143\u7d20\u8bbf\u95ee\u5ef6\u8fdf\u53d8\u9ad8\u3002\u5728\u5f53\u524d\u6280\u672f\u4e0b\uff0c\u591a\u5c42\u7ea7\u7684\u7f13\u5b58\u7ed3\u6784\u662f\u5bb9\u91cf\u3001\u901f\u5ea6\u548c\u6210\u672c\u4e4b\u95f4\u7684\u6700\u4f73\u5e73\u8861\u70b9\u3002

    \u56fe 4-9 \u00a0 \u8ba1\u7b97\u673a\u5b58\u50a8\u7cfb\u7edf

    Note

    \u8ba1\u7b97\u673a\u7684\u5b58\u50a8\u5c42\u6b21\u7ed3\u6784\u4f53\u73b0\u4e86\u901f\u5ea6\u3001\u5bb9\u91cf\u548c\u6210\u672c\u4e09\u8005\u4e4b\u95f4\u7684\u7cbe\u5999\u5e73\u8861\u3002\u5b9e\u9645\u4e0a\uff0c\u8fd9\u79cd\u6743\u8861\u666e\u904d\u5b58\u5728\u4e8e\u6240\u6709\u5de5\u4e1a\u9886\u57df\uff0c\u5b83\u8981\u6c42\u6211\u4eec\u5728\u4e0d\u540c\u7684\u4f18\u52bf\u548c\u9650\u5236\u4e4b\u95f4\u627e\u5230\u6700\u4f73\u5e73\u8861\u70b9\u3002

    \u603b\u7684\u6765\u8bf4\uff0c\u786c\u76d8\u7528\u4e8e\u957f\u671f\u5b58\u50a8\u5927\u91cf\u6570\u636e\uff0c\u5185\u5b58\u7528\u4e8e\u4e34\u65f6\u5b58\u50a8\u7a0b\u5e8f\u8fd0\u884c\u4e2d\u6b63\u5728\u5904\u7406\u7684\u6570\u636e\uff0c\u800c\u7f13\u5b58\u5219\u7528\u4e8e\u5b58\u50a8\u7ecf\u5e38\u8bbf\u95ee\u7684\u6570\u636e\u548c\u6307\u4ee4\uff0c\u4ee5\u63d0\u9ad8\u7a0b\u5e8f\u8fd0\u884c\u6548\u7387\u3002\u4e09\u8005\u5171\u540c\u534f\u4f5c\uff0c\u786e\u4fdd\u8ba1\u7b97\u673a\u7cfb\u7edf\u9ad8\u6548\u8fd0\u884c\u3002

    \u5982\u56fe 4-10 \u6240\u793a\uff0c\u5728\u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u6570\u636e\u4f1a\u4ece\u786c\u76d8\u4e2d\u88ab\u8bfb\u53d6\u5230\u5185\u5b58\u4e2d\uff0c\u4f9b CPU \u8ba1\u7b97\u4f7f\u7528\u3002\u7f13\u5b58\u53ef\u4ee5\u770b\u4f5c CPU \u7684\u4e00\u90e8\u5206\uff0c\u5b83\u901a\u8fc7\u667a\u80fd\u5730\u4ece\u5185\u5b58\u52a0\u8f7d\u6570\u636e\uff0c\u7ed9 CPU \u63d0\u4f9b\u9ad8\u901f\u7684\u6570\u636e\u8bfb\u53d6\uff0c\u4ece\u800c\u663e\u8457\u63d0\u5347\u7a0b\u5e8f\u7684\u6267\u884c\u6548\u7387\uff0c\u51cf\u5c11\u5bf9\u8f83\u6162\u7684\u5185\u5b58\u7684\u4f9d\u8d56\u3002

    \u56fe 4-10 \u00a0 \u786c\u76d8\u3001\u5185\u5b58\u548c\u7f13\u5b58\u4e4b\u95f4\u7684\u6570\u636e\u6d41\u901a

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442","title":"4.4.2 \u00a0 \u6570\u636e\u7ed3\u6784\u7684\u5185\u5b58\u6548\u7387","text":"

    \u5728\u5185\u5b58\u7a7a\u95f4\u5229\u7528\u65b9\u9762\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u5404\u81ea\u5177\u6709\u4f18\u52bf\u548c\u5c40\u9650\u6027\u3002

    \u4e00\u65b9\u9762\uff0c\u5185\u5b58\u662f\u6709\u9650\u7684\uff0c\u4e14\u540c\u4e00\u5757\u5185\u5b58\u4e0d\u80fd\u88ab\u591a\u4e2a\u7a0b\u5e8f\u5171\u4eab\uff0c\u56e0\u6b64\u6211\u4eec\u5e0c\u671b\u6570\u636e\u7ed3\u6784\u80fd\u591f\u5c3d\u53ef\u80fd\u9ad8\u6548\u5730\u5229\u7528\u7a7a\u95f4\u3002\u6570\u7ec4\u7684\u5143\u7d20\u7d27\u5bc6\u6392\u5217\uff0c\u4e0d\u9700\u8981\u989d\u5916\u7684\u7a7a\u95f4\u6765\u5b58\u50a8\u94fe\u8868\u8282\u70b9\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\uff0c\u56e0\u6b64\u7a7a\u95f4\u6548\u7387\u66f4\u9ad8\u3002\u7136\u800c\uff0c\u6570\u7ec4\u9700\u8981\u4e00\u6b21\u6027\u5206\u914d\u8db3\u591f\u7684\u8fde\u7eed\u5185\u5b58\u7a7a\u95f4\uff0c\u8fd9\u53ef\u80fd\u5bfc\u81f4\u5185\u5b58\u6d6a\u8d39\uff0c\u6570\u7ec4\u6269\u5bb9\u4e5f\u9700\u8981\u989d\u5916\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u6210\u672c\u3002\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u94fe\u8868\u4ee5\u201c\u8282\u70b9\u201d\u4e3a\u5355\u4f4d\u8fdb\u884c\u52a8\u6001\u5185\u5b58\u5206\u914d\u548c\u56de\u6536\uff0c\u63d0\u4f9b\u4e86\u66f4\u5927\u7684\u7075\u6d3b\u6027\u3002

    \u53e6\u4e00\u65b9\u9762\uff0c\u5728\u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u968f\u7740\u53cd\u590d\u7533\u8bf7\u4e0e\u91ca\u653e\u5185\u5b58\uff0c\u7a7a\u95f2\u5185\u5b58\u7684\u788e\u7247\u5316\u7a0b\u5ea6\u4f1a\u8d8a\u6765\u8d8a\u9ad8\uff0c\u4ece\u800c\u5bfc\u81f4\u5185\u5b58\u7684\u5229\u7528\u6548\u7387\u964d\u4f4e\u3002\u6570\u7ec4\u7531\u4e8e\u5176\u8fde\u7eed\u7684\u5b58\u50a8\u65b9\u5f0f\uff0c\u76f8\u5bf9\u4e0d\u5bb9\u6613\u5bfc\u81f4\u5185\u5b58\u788e\u7247\u5316\u3002\u76f8\u53cd\uff0c\u94fe\u8868\u7684\u5143\u7d20\u662f\u5206\u6563\u5b58\u50a8\u7684\uff0c\u5728\u9891\u7e41\u7684\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u4e2d\uff0c\u66f4\u5bb9\u6613\u5bfc\u81f4\u5185\u5b58\u788e\u7247\u5316\u3002

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443","title":"4.4.3 \u00a0 \u6570\u636e\u7ed3\u6784\u7684\u7f13\u5b58\u6548\u7387","text":"

    \u7f13\u5b58\u867d\u7136\u5728\u7a7a\u95f4\u5bb9\u91cf\u4e0a\u8fdc\u5c0f\u4e8e\u5185\u5b58\uff0c\u4f46\u5b83\u6bd4\u5185\u5b58\u5feb\u5f97\u591a\uff0c\u5728\u7a0b\u5e8f\u6267\u884c\u901f\u5ea6\u4e0a\u8d77\u7740\u81f3\u5173\u91cd\u8981\u7684\u4f5c\u7528\u3002\u7531\u4e8e\u7f13\u5b58\u7684\u5bb9\u91cf\u6709\u9650\uff0c\u53ea\u80fd\u5b58\u50a8\u4e00\u5c0f\u90e8\u5206\u9891\u7e41\u8bbf\u95ee\u7684\u6570\u636e\uff0c\u56e0\u6b64\u5f53 CPU \u5c1d\u8bd5\u8bbf\u95ee\u7684\u6570\u636e\u4e0d\u5728\u7f13\u5b58\u4e2d\u65f6\uff0c\u5c31\u4f1a\u53d1\u751f\u300c\u7f13\u5b58\u672a\u547d\u4e2d cache miss\u300d\uff0c\u6b64\u65f6 CPU \u4e0d\u5f97\u4e0d\u4ece\u901f\u5ea6\u8f83\u6162\u7684\u5185\u5b58\u4e2d\u52a0\u8f7d\u6240\u9700\u6570\u636e\u3002

    \u663e\u7136\uff0c\u201c\u7f13\u5b58\u672a\u547d\u4e2d\u201d\u8d8a\u5c11\uff0cCPU \u8bfb\u5199\u6570\u636e\u7684\u6548\u7387\u5c31\u8d8a\u9ad8\uff0c\u7a0b\u5e8f\u6027\u80fd\u4e5f\u5c31\u8d8a\u597d\u3002\u6211\u4eec\u5c06 CPU \u4ece\u7f13\u5b58\u4e2d\u6210\u529f\u83b7\u53d6\u6570\u636e\u7684\u6bd4\u4f8b\u79f0\u4e3a\u300c\u7f13\u5b58\u547d\u4e2d\u7387 cache hit rate\u300d\uff0c\u8fd9\u4e2a\u6307\u6807\u901a\u5e38\u7528\u6765\u8861\u91cf\u7f13\u5b58\u6548\u7387\u3002

    \u4e3a\u4e86\u5c3d\u53ef\u80fd\u8fbe\u5230\u66f4\u9ad8\u7684\u6548\u7387\uff0c\u7f13\u5b58\u4f1a\u91c7\u53d6\u4ee5\u4e0b\u6570\u636e\u52a0\u8f7d\u673a\u5236\u3002

    • \u7f13\u5b58\u884c\uff1a\u7f13\u5b58\u4e0d\u662f\u5355\u4e2a\u5b57\u8282\u5730\u5b58\u50a8\u4e0e\u52a0\u8f7d\u6570\u636e\uff0c\u800c\u662f\u4ee5\u7f13\u5b58\u884c\u4e3a\u5355\u4f4d\u3002\u76f8\u6bd4\u4e8e\u5355\u4e2a\u5b57\u8282\u7684\u4f20\u8f93\uff0c\u7f13\u5b58\u884c\u7684\u4f20\u8f93\u5f62\u5f0f\u66f4\u52a0\u9ad8\u6548\u3002
    • \u9884\u53d6\u673a\u5236\uff1a\u5904\u7406\u5668\u4f1a\u5c1d\u8bd5\u9884\u6d4b\u6570\u636e\u8bbf\u95ee\u6a21\u5f0f\uff08\u4f8b\u5982\u987a\u5e8f\u8bbf\u95ee\u3001\u56fa\u5b9a\u6b65\u957f\u8df3\u8dc3\u8bbf\u95ee\u7b49\uff09\uff0c\u5e76\u6839\u636e\u7279\u5b9a\u6a21\u5f0f\u5c06\u6570\u636e\u52a0\u8f7d\u81f3\u7f13\u5b58\u4e4b\u4e2d\uff0c\u4ece\u800c\u63d0\u5347\u547d\u4e2d\u7387\u3002
    • \u7a7a\u95f4\u5c40\u90e8\u6027\uff1a\u5982\u679c\u4e00\u4e2a\u6570\u636e\u88ab\u8bbf\u95ee\uff0c\u90a3\u4e48\u5b83\u9644\u8fd1\u7684\u6570\u636e\u53ef\u80fd\u8fd1\u671f\u4e5f\u4f1a\u88ab\u8bbf\u95ee\u3002\u56e0\u6b64\uff0c\u7f13\u5b58\u5728\u52a0\u8f7d\u67d0\u4e00\u6570\u636e\u65f6\uff0c\u4e5f\u4f1a\u52a0\u8f7d\u5176\u9644\u8fd1\u7684\u6570\u636e\uff0c\u4ee5\u63d0\u9ad8\u547d\u4e2d\u7387\u3002
    • \u65f6\u95f4\u5c40\u90e8\u6027\uff1a\u5982\u679c\u4e00\u4e2a\u6570\u636e\u88ab\u8bbf\u95ee\uff0c\u90a3\u4e48\u5b83\u5728\u4e0d\u4e45\u7684\u5c06\u6765\u5f88\u53ef\u80fd\u518d\u6b21\u88ab\u8bbf\u95ee\u3002\u7f13\u5b58\u5229\u7528\u8fd9\u4e00\u539f\u7406\uff0c\u901a\u8fc7\u4fdd\u7559\u6700\u8fd1\u8bbf\u95ee\u8fc7\u7684\u6570\u636e\u6765\u63d0\u9ad8\u547d\u4e2d\u7387\u3002

    \u5b9e\u9645\u4e0a\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u5bf9\u7f13\u5b58\u7684\u5229\u7528\u6548\u7387\u662f\u4e0d\u540c\u7684\uff0c\u4e3b\u8981\u4f53\u73b0\u5728\u4ee5\u4e0b\u51e0\u4e2a\u65b9\u9762\u3002

    • \u5360\u7528\u7a7a\u95f4\uff1a\u94fe\u8868\u5143\u7d20\u6bd4\u6570\u7ec4\u5143\u7d20\u5360\u7528\u7a7a\u95f4\u66f4\u591a\uff0c\u5bfc\u81f4\u7f13\u5b58\u4e2d\u5bb9\u7eb3\u7684\u6709\u6548\u6570\u636e\u91cf\u66f4\u5c11\u3002
    • \u7f13\u5b58\u884c\uff1a\u94fe\u8868\u6570\u636e\u5206\u6563\u5728\u5185\u5b58\u5404\u5904\uff0c\u800c\u7f13\u5b58\u662f\u201c\u6309\u884c\u52a0\u8f7d\u201d\u7684\uff0c\u56e0\u6b64\u52a0\u8f7d\u5230\u65e0\u6548\u6570\u636e\u7684\u6bd4\u4f8b\u66f4\u9ad8\u3002
    • \u9884\u53d6\u673a\u5236\uff1a\u6570\u7ec4\u6bd4\u94fe\u8868\u7684\u6570\u636e\u8bbf\u95ee\u6a21\u5f0f\u66f4\u5177\u201c\u53ef\u9884\u6d4b\u6027\u201d\uff0c\u5373\u7cfb\u7edf\u66f4\u5bb9\u6613\u731c\u51fa\u5373\u5c06\u88ab\u52a0\u8f7d\u7684\u6570\u636e\u3002
    • \u7a7a\u95f4\u5c40\u90e8\u6027\uff1a\u6570\u7ec4\u88ab\u5b58\u50a8\u5728\u96c6\u4e2d\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u56e0\u6b64\u88ab\u52a0\u8f7d\u6570\u636e\u9644\u8fd1\u7684\u6570\u636e\u66f4\u6709\u53ef\u80fd\u5373\u5c06\u88ab\u8bbf\u95ee\u3002

    \u603b\u4f53\u800c\u8a00\uff0c\u6570\u7ec4\u5177\u6709\u66f4\u9ad8\u7684\u7f13\u5b58\u547d\u4e2d\u7387\uff0c\u56e0\u6b64\u5b83\u5728\u64cd\u4f5c\u6548\u7387\u4e0a\u901a\u5e38\u4f18\u4e8e\u94fe\u8868\u3002\u8fd9\u4f7f\u5f97\u5728\u89e3\u51b3\u7b97\u6cd5\u95ee\u9898\u65f6\uff0c\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u5f80\u5f80\u66f4\u53d7\u6b22\u8fce\u3002

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u9ad8\u7f13\u5b58\u6548\u7387\u5e76\u4e0d\u610f\u5473\u7740\u6570\u7ec4\u5728\u6240\u6709\u60c5\u51b5\u4e0b\u90fd\u4f18\u4e8e\u94fe\u8868\u3002\u5b9e\u9645\u5e94\u7528\u4e2d\u9009\u62e9\u54ea\u79cd\u6570\u636e\u7ed3\u6784\uff0c\u5e94\u6839\u636e\u5177\u4f53\u9700\u6c42\u6765\u51b3\u5b9a\u3002\u4f8b\u5982\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u90fd\u53ef\u4ee5\u5b9e\u73b0\u201c\u6808\u201d\u6570\u636e\u7ed3\u6784\uff08\u4e0b\u4e00\u7ae0\u4f1a\u8be6\u7ec6\u4ecb\u7ecd\uff09\uff0c\u4f46\u5b83\u4eec\u9002\u7528\u4e8e\u4e0d\u540c\u573a\u666f\u3002

    • \u5728\u505a\u7b97\u6cd5\u9898\u65f6\uff0c\u6211\u4eec\u4f1a\u503e\u5411\u4e8e\u9009\u62e9\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\uff0c\u56e0\u4e3a\u5b83\u63d0\u4f9b\u4e86\u66f4\u9ad8\u7684\u64cd\u4f5c\u6548\u7387\u548c\u968f\u673a\u8bbf\u95ee\u7684\u80fd\u529b\uff0c\u4ee3\u4ef7\u4ec5\u662f\u9700\u8981\u9884\u5148\u4e3a\u6570\u7ec4\u5206\u914d\u4e00\u5b9a\u7684\u5185\u5b58\u7a7a\u95f4\u3002
    • \u5982\u679c\u6570\u636e\u91cf\u975e\u5e38\u5927\u3001\u52a8\u6001\u6027\u5f88\u9ad8\u3001\u6808\u7684\u9884\u671f\u5927\u5c0f\u96be\u4ee5\u4f30\u8ba1\uff0c\u90a3\u4e48\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\u66f4\u52a0\u5408\u9002\u3002\u94fe\u8868\u80fd\u591f\u5c06\u5927\u91cf\u6570\u636e\u5206\u6563\u5b58\u50a8\u4e8e\u5185\u5b58\u7684\u4e0d\u540c\u90e8\u5206\uff0c\u5e76\u4e14\u907f\u514d\u4e86\u6570\u7ec4\u6269\u5bb9\u4ea7\u751f\u7684\u989d\u5916\u5f00\u9500\u3002
    "},{"location":"chapter_array_and_linkedlist/summary/","title":"4.5 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_array_and_linkedlist/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","text":"
    • \u6570\u7ec4\u548c\u94fe\u8868\u662f\u4e24\u79cd\u57fa\u672c\u7684\u6570\u636e\u7ed3\u6784\uff0c\u5206\u522b\u4ee3\u8868\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u4e24\u79cd\u5b58\u50a8\u65b9\u5f0f\uff1a\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u548c\u5206\u6563\u7a7a\u95f4\u5b58\u50a8\u3002\u4e24\u8005\u7684\u7279\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\u5f15\u7528\uff08\u6307\u9488\uff09\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\u73af\u5f62\u94fe\u8868\u3001\u53cc\u5411\u94fe\u8868\u3002
    • \u5217\u8868\u662f\u4e00\u79cd\u652f\u6301\u589e\u5220\u67e5\u6539\u7684\u5143\u7d20\u6709\u5e8f\u96c6\u5408\uff0c\u901a\u5e38\u57fa\u4e8e\u52a8\u6001\u6570\u7ec4\u5b9e\u73b0\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\u5927\u5e45\u63d0\u9ad8\u4e86\u6570\u7ec4\u7684\u5b9e\u7528\u6027\uff0c\u4f46\u53ef\u80fd\u5bfc\u81f4\u90e8\u5206\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u3002
    • \u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u6570\u636e\u4e3b\u8981\u5b58\u50a8\u5728\u5185\u5b58\u4e2d\u3002\u6570\u7ec4\u53ef\u63d0\u4f9b\u66f4\u9ad8\u7684\u5185\u5b58\u7a7a\u95f4\u6548\u7387\uff0c\u800c\u94fe\u8868\u5219\u5728\u5185\u5b58\u4f7f\u7528\u4e0a\u66f4\u52a0\u7075\u6d3b\u3002
    • \u7f13\u5b58\u901a\u8fc7\u7f13\u5b58\u884c\u3001\u9884\u53d6\u673a\u5236\u4ee5\u53ca\u7a7a\u95f4\u5c40\u90e8\u6027\u548c\u65f6\u95f4\u5c40\u90e8\u6027\u7b49\u6570\u636e\u52a0\u8f7d\u673a\u5236\uff0c\u4e3a CPU \u63d0\u4f9b\u5feb\u901f\u6570\u636e\u8bbf\u95ee\uff0c\u663e\u8457\u63d0\u5347\u7a0b\u5e8f\u7684\u6267\u884c\u6548\u7387\u3002
    • \u7531\u4e8e\u6570\u7ec4\u5177\u6709\u66f4\u9ad8\u7684\u7f13\u5b58\u547d\u4e2d\u7387\uff0c\u56e0\u6b64\u5b83\u901a\u5e38\u6bd4\u94fe\u8868\u66f4\u9ad8\u6548\u3002\u5728\u9009\u62e9\u6570\u636e\u7ed3\u6784\u65f6\uff0c\u5e94\u6839\u636e\u5177\u4f53\u9700\u6c42\u548c\u573a\u666f\u505a\u51fa\u6070\u5f53\u9009\u62e9\u3002
    "},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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

    \u5b58\u50a8\u5728\u6808\u4e0a\u548c\u5806\u4e0a\u7684\u6570\u7ec4\u90fd\u88ab\u5b58\u50a8\u5728\u8fde\u7eed\u5185\u5b58\u7a7a\u95f4\u5185\uff0c\u6570\u636e\u64cd\u4f5c\u6548\u7387\u57fa\u672c\u4e00\u81f4\u3002\u7136\u800c\uff0c\u6808\u548c\u5806\u5177\u6709\u5404\u81ea\u7684\u7279\u70b9\uff0c\u4ece\u800c\u5bfc\u81f4\u4ee5\u4e0b\u4e0d\u540c\u70b9\u3002

    1. \u5206\u914d\u548c\u91ca\u653e\u6548\u7387\uff1a\u6808\u662f\u4e00\u5757\u8f83\u5c0f\u7684\u5185\u5b58\uff0c\u5206\u914d\u7531\u7f16\u8bd1\u5668\u81ea\u52a8\u5b8c\u6210\uff1b\u800c\u5806\u5185\u5b58\u76f8\u5bf9\u66f4\u5927\uff0c\u53ef\u4ee5\u5728\u4ee3\u7801\u4e2d\u52a8\u6001\u5206\u914d\uff0c\u66f4\u5bb9\u6613\u788e\u7247\u5316\u3002\u56e0\u6b64\uff0c\u5806\u4e0a\u7684\u5206\u914d\u548c\u91ca\u653e\u64cd\u4f5c\u901a\u5e38\u6bd4\u6808\u4e0a\u7684\u6162\u3002
    2. \u5927\u5c0f\u9650\u5236\uff1a\u6808\u5185\u5b58\u76f8\u5bf9\u8f83\u5c0f\uff0c\u5806\u7684\u5927\u5c0f\u4e00\u822c\u53d7\u9650\u4e8e\u53ef\u7528\u5185\u5b58\u3002\u56e0\u6b64\u5806\u66f4\u52a0\u9002\u5408\u5b58\u50a8\u5927\u578b\u6570\u7ec4\u3002
    3. \u7075\u6d3b\u6027\uff1a\u6808\u4e0a\u7684\u6570\u7ec4\u7684\u5927\u5c0f\u9700\u8981\u5728\u7f16\u8bd1\u65f6\u786e\u5b9a\uff0c\u800c\u5806\u4e0a\u7684\u6570\u7ec4\u7684\u5927\u5c0f\u53ef\u4ee5\u5728\u8fd0\u884c\u65f6\u52a8\u6001\u786e\u5b9a\u3002

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

    \u94fe\u8868\u7531\u8282\u70b9\u7ec4\u6210\uff0c\u8282\u70b9\u4e4b\u95f4\u901a\u8fc7\u5f15\u7528\uff08\u6307\u9488\uff09\u8fde\u63a5\uff0c\u5404\u4e2a\u8282\u70b9\u53ef\u4ee5\u5b58\u50a8\u4e0d\u540c\u7c7b\u578b\u7684\u6570\u636e\uff0c\u4f8b\u5982 int\u3001double\u3001string\u3001object \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\u6570\u7ec4\u540c\u65f6\u5305\u542b int \u548c long \u4e24\u79cd\u7c7b\u578b\uff0c\u5355\u4e2a\u5143\u7d20\u5206\u522b\u5360\u7528 4 \u5b57\u8282 \u548c 8 \u5b57\u8282 \uff0c\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\u201c\u5143\u7d20\u957f\u5ea6\u201d\u3002

    # \u5143\u7d20\u5185\u5b58\u5730\u5740 = \u6570\u7ec4\u5185\u5b58\u5730\u5740\uff08\u9996\u5143\u7d20\u5185\u5b58\u5730\u5740\uff09 + \u5143\u7d20\u957f\u5ea6 * \u5143\u7d20\u7d22\u5f15\n

    Q\uff1a\u5220\u9664\u8282\u70b9 P \u540e\uff0c\u662f\u5426\u9700\u8981\u628a P.next \u8bbe\u4e3a None \u5462\uff1f

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

    \u4ece\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\uff08\u505a\u9898\uff09\u7684\u89d2\u5ea6\u770b\uff0c\u4e0d\u65ad\u5f00\u6ca1\u6709\u5173\u7cfb\uff0c\u53ea\u8981\u4fdd\u8bc1\u7a0b\u5e8f\u7684\u903b\u8f91\u662f\u6b63\u786e\u7684\u5c31\u884c\u3002\u4ece\u6807\u51c6\u5e93\u7684\u89d2\u5ea6\u770b\uff0c\u65ad\u5f00\u66f4\u52a0\u5b89\u5168\u3001\u903b\u8f91\u66f4\u52a0\u6e05\u6670\u3002\u5982\u679c\u4e0d\u65ad\u5f00\uff0c\u5047\u8bbe\u88ab\u5220\u9664\u8282\u70b9\u672a\u88ab\u6b63\u5e38\u56de\u6536\uff0c\u90a3\u4e48\u5b83\u4f1a\u5f71\u54cd\u540e\u7ee7\u8282\u70b9\u7684\u5185\u5b58\u56de\u6536\u3002

    Q\uff1a\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)\\) \u7684\u65f6\u95f4\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\u65f6\u95f4\u590d\u6742\u5ea6\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\u8282\u70b9\u3001\u5c3e\u8282\u70b9\uff0c\u6bcf\u6b21\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u90fd\u662f \\(O(1)\\) \u3002

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

    \u8be5\u793a\u610f\u56fe\u53ea\u662f\u5b9a\u6027\u8868\u793a\uff0c\u5b9a\u91cf\u8868\u793a\u9700\u8981\u6839\u636e\u5177\u4f53\u60c5\u51b5\u8fdb\u884c\u5206\u6790\u3002

    • \u4e0d\u540c\u7c7b\u578b\u7684\u8282\u70b9\u503c\u5360\u7528\u7684\u7a7a\u95f4\u662f\u4e0d\u540c\u7684\uff0c\u6bd4\u5982 int\u3001long\u3001double \u548c\u5b9e\u4f8b\u5bf9\u8c61\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

    Q\uff1a\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

    Q\uff1a\u201c\u5217\u8868\u7684\u51fa\u73b0\u6781\u5927\u5730\u63d0\u9ad8\u4e86\u6570\u7ec4\u7684\u5b9e\u7528\u6027\uff0c\u4f46\u53ef\u80fd\u5bfc\u81f4\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\uff1b\u53e6\u4e00\u65b9\u9762\uff0c\u4e3a\u4e86\u9632\u6b62\u9891\u7e41\u6269\u5bb9\uff0c\u6269\u5bb9\u4e00\u822c\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

    Q\uff1a\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\u7684\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 5 \u4e2a\u8282\u70b9\u5bf9\u8c61\u4e5f\u5206\u6563\u5b58\u50a8\u5728\u5185\u5b58\u5404\u5904\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\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\uff0cPython \u4e2d\u7684\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\u65e0\u987b\u8fde\u7eed\u3002

    Q\uff1aC++ STL \u91cc\u9762\u7684 std::list \u5df2\u7ecf\u5b9e\u73b0\u4e86\u53cc\u5411\u94fe\u8868\uff0c\u4f46\u597d\u50cf\u4e00\u4e9b\u7b97\u6cd5\u4e66\u4e0a\u4e0d\u600e\u4e48\u76f4\u63a5\u4f7f\u7528\u5b83\uff0c\u662f\u4e0d\u662f\u56e0\u4e3a\u6709\u4ec0\u4e48\u5c40\u9650\u6027\u5462\uff1f

    \u4e00\u65b9\u9762\uff0c\u6211\u4eec\u5f80\u5f80\u66f4\u9752\u7750\u4f7f\u7528\u6570\u7ec4\u5b9e\u73b0\u7b97\u6cd5\uff0c\u800c\u53ea\u5728\u5fc5\u8981\u65f6\u624d\u4f7f\u7528\u94fe\u8868\uff0c\u4e3b\u8981\u6709\u4e24\u4e2a\u539f\u56e0\u3002

    • \u7a7a\u95f4\u5f00\u9500\uff1a\u7531\u4e8e\u6bcf\u4e2a\u5143\u7d20\u9700\u8981\u4e24\u4e2a\u989d\u5916\u7684\u6307\u9488\uff08\u4e00\u4e2a\u7528\u4e8e\u524d\u4e00\u4e2a\u5143\u7d20\uff0c\u4e00\u4e2a\u7528\u4e8e\u540e\u4e00\u4e2a\u5143\u7d20\uff09\uff0c\u6240\u4ee5 std::list \u901a\u5e38\u6bd4 std::vector \u66f4\u5360\u7528\u7a7a\u95f4\u3002
    • \u7f13\u5b58\u4e0d\u53cb\u597d\uff1a\u7531\u4e8e\u6570\u636e\u4e0d\u662f\u8fde\u7eed\u5b58\u653e\u7684\uff0c\u56e0\u6b64 std::list \u5bf9\u7f13\u5b58\u7684\u5229\u7528\u7387\u8f83\u4f4e\u3002\u4e00\u822c\u60c5\u51b5\u4e0b\uff0cstd::vector \u7684\u6027\u80fd\u4f1a\u66f4\u597d\u3002

    \u53e6\u4e00\u65b9\u9762\uff0c\u5fc5\u8981\u4f7f\u7528\u94fe\u8868\u7684\u60c5\u51b5\u4e3b\u8981\u662f\u4e8c\u53c9\u6811\u548c\u56fe\u3002\u6808\u548c\u961f\u5217\u5f80\u5f80\u4f1a\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u63d0\u4f9b\u7684 stack \u548c queue \uff0c\u800c\u975e\u94fe\u8868\u3002

    Q\uff1a\u521d\u59cb\u5316\u5217\u8868 res = [0] * self.size() \u64cd\u4f5c\uff0c\u4f1a\u5bfc\u81f4 res \u7684\u6bcf\u4e2a\u5143\u7d20\u5f15\u7528\u76f8\u540c\u7684\u5730\u5740\u5417\uff1f

    \u4e0d\u4f1a\u3002\u4f46\u4e8c\u7ef4\u6570\u7ec4\u4f1a\u6709\u8fd9\u4e2a\u95ee\u9898\uff0c\u4f8b\u5982\u521d\u59cb\u5316\u4e8c\u7ef4\u5217\u8868 res = [[0] * self.size()] \uff0c\u5219\u591a\u6b21\u5f15\u7528\u4e86\u540c\u4e00\u4e2a\u5217\u8868 [0] \u3002

    "},{"location":"chapter_backtracking/","title":"\u7b2c 13 \u7ae0 \u00a0 \u56de\u6eaf","text":"

    Abstract

    \u6211\u4eec\u5982\u540c\u8ff7\u5bab\u4e2d\u7684\u63a2\u7d22\u8005\uff0c\u5728\u524d\u8fdb\u7684\u9053\u8def\u4e0a\u53ef\u80fd\u4f1a\u9047\u5230\u56f0\u96be\u3002

    \u56de\u6eaf\u7684\u529b\u91cf\u8ba9\u6211\u4eec\u80fd\u591f\u91cd\u65b0\u5f00\u59cb\uff0c\u4e0d\u65ad\u5c1d\u8bd5\uff0c\u6700\u7ec8\u627e\u5230\u901a\u5f80\u5149\u660e\u7684\u51fa\u53e3\u3002

    "},{"location":"chapter_backtracking/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 13.1 \u00a0 \u56de\u6eaf\u7b97\u6cd5
    • 13.2 \u00a0 \u5168\u6392\u5217\u95ee\u9898
    • 13.3 \u00a0 \u5b50\u96c6\u548c\u95ee\u9898
    • 13.4 \u00a0 N \u7687\u540e\u95ee\u9898
    • 13.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_backtracking/backtracking_algorithm/","title":"13.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\u201c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u201d\u6765\u904d\u5386\u89e3\u7a7a\u95f4\u3002\u5728\u201c\u4e8c\u53c9\u6811\u201d\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\uff0c\u6211\u4eec\u5229\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\u68f5\u4e8c\u53c9\u6811\uff0c\u641c\u7d22\u5e76\u8bb0\u5f55\u6240\u6709\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\uff0c\u8bf7\u8fd4\u56de\u8282\u70b9\u5217\u8868\u3002

    \u5bf9\u4e8e\u6b64\u9898\uff0c\u6211\u4eec\u524d\u5e8f\u904d\u5386\u8fd9\u68f5\u6811\uff0c\u5e76\u5224\u65ad\u5f53\u524d\u8282\u70b9\u7684\u503c\u662f\u5426\u4e3a \\(7\\) \uff0c\u82e5\u662f\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u7684\u503c\u52a0\u5165\u7ed3\u679c\u5217\u8868 res \u4e4b\u4e2d\u3002\u76f8\u5173\u8fc7\u7a0b\u5b9e\u73b0\u5982\u56fe 13-1 \u548c\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig preorder_traversal_i_compact.py
    def pre_order(root: TreeNode):\n    \"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # \u8bb0\u5f55\u89e3\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n
    preorder_traversal_i_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push_back(root);\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n}\n
    preorder_traversal_i_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n
    preorder_traversal_i_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n
    preorder_traversal_i_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // \u8bb0\u5f55\u89e3\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n
    preorder_traversal_i_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // \u8bb0\u5f55\u89e3\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n
    preorder_traversal_i_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(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 {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n
    preorder_traversal_i_compact.dart
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode? root, List<TreeNode> res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // \u8bb0\u5f55\u89e3\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n
    preorder_traversal_i_compact.rs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfn pre_order(res: &mut Vec<Rc<RefCell<TreeNode>>>, root: Option<Rc<RefCell<TreeNode>>>) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // \u8bb0\u5f55\u89e3\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.clone());\n        pre_order(res, node.borrow().right.clone());\n    }\n}\n
    preorder_traversal_i_compact.c
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res[resSize++] = root;\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n}\n
    preorder_traversal_i_compact.kt
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root.value == 7) {\n        // \u8bb0\u5f55\u89e3\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n
    preorder_traversal_i_compact.rb
    [class]{}-[func]{pre_order}\n
    preorder_traversal_i_compact.zig
    [class]{}-[func]{preOrder}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 13-1 \u00a0 \u5728\u524d\u5e8f\u904d\u5386\u4e2d\u641c\u7d22\u8282\u70b9

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1311","title":"13.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\u8282\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\u4ec5\u4ec5\u5305\u62ec\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\u8bf7\u8fd4\u56de\u6839\u8282\u70b9\u5230\u8fd9\u4e9b\u8282\u70b9\u7684\u8def\u5f84\u3002

    \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig preorder_traversal_ii_compact.py
    def pre_order(root: TreeNode):\n    \"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c\"\"\"\n    if root is None:\n        return\n    # \u5c1d\u8bd5\n    path.append(root)\n    if root.val == 7:\n        # \u8bb0\u5f55\u89e3\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # \u56de\u9000\n    path.pop()\n
    preorder_traversal_ii_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push_back(root);\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push_back(path);\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n    // \u56de\u9000\n    path.pop_back();\n}\n
    preorder_traversal_ii_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.add(root);\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.add(new ArrayList<>(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // \u56de\u9000\n    path.remove(path.size() - 1);\n}\n
    preorder_traversal_ii_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.Add(root);\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.Add(new List<TreeNode>(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // \u56de\u9000\n    path.RemoveAt(path.Count - 1);\n}\n
    preorder_traversal_ii_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // \u5c1d\u8bd5\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // \u8bb0\u5f55\u89e3\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // \u56de\u9000\n    *path = (*path)[:len(*path)-1]\n}\n
    preorder_traversal_ii_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u5c1d\u8bd5\n    path.append(root)\n    if root.val == 7 {\n        // \u8bb0\u5f55\u89e3\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // \u56de\u9000\n    path.removeLast()\n}\n
    preorder_traversal_ii_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push(root);\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // \u56de\u9000\n    path.pop();\n}\n
    preorder_traversal_ii_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push(root);\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // \u56de\u9000\n    path.pop();\n}\n
    preorder_traversal_ii_compact.dart
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(\n  TreeNode? root,\n  List<TreeNode> path,\n  List<List<TreeNode>> res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // \u5c1d\u8bd5\n  path.add(root);\n  if (root.val == 7) {\n    // \u8bb0\u5f55\u89e3\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // \u56de\u9000\n  path.removeLast();\n}\n
    preorder_traversal_ii_compact.rs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfn pre_order(\n    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,\n    path: &mut Vec<Rc<RefCell<TreeNode>>>,\n    root: Option<Rc<RefCell<TreeNode>>>,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // \u5c1d\u8bd5\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // \u8bb0\u5f55\u89e3\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.clone());\n        pre_order(res, path, node.borrow().right.clone());\n        // \u56de\u9000\n        path.remove(path.len() - 1);\n    }\n}\n
    preorder_traversal_ii_compact.c
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path[pathSize++] = root;\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        for (int i = 0; i < pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n    // \u56de\u9000\n    pathSize--;\n}\n
    preorder_traversal_ii_compact.kt
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // \u5c1d\u8bd5\n    path!!.add(root)\n    if (root.value == 7) {\n        // \u8bb0\u5f55\u89e3\n        res!!.add(ArrayList(path!!))\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // \u56de\u9000\n    path!!.removeAt(path!!.size - 1)\n}\n
    preorder_traversal_ii_compact.rb
    [class]{}-[func]{pre_order}\n
    preorder_traversal_ii_compact.zig
    [class]{}-[func]{preOrder}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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

    \u89c2\u5bdf\u56fe 13-2 \u6240\u793a\u7684\u8fc7\u7a0b\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\u4e92\u4e3a\u9006\u5411\u3002

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

    \u56fe 13-2 \u00a0 \u5c1d\u8bd5\u4e0e\u56de\u9000

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1312","title":"13.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\u8bf7\u8fd4\u56de\u6839\u8282\u70b9\u5230\u8fd9\u4e9b\u8282\u70b9\u7684\u8def\u5f84\uff0c\u5e76\u8981\u6c42\u8def\u5f84\u4e2d\u4e0d\u5305\u542b\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u3002

    \u4e3a\u4e86\u6ee1\u8db3\u4ee5\u4e0a\u7ea6\u675f\u6761\u4ef6\uff0c\u6211\u4eec\u9700\u8981\u6dfb\u52a0\u526a\u679d\u64cd\u4f5c\uff1a\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u82e5\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\uff0c\u5219\u63d0\u524d\u8fd4\u56de\uff0c\u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig preorder_traversal_iii_compact.py
    def pre_order(root: TreeNode):\n    \"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09\"\"\"\n    # \u526a\u679d\n    if root is None or root.val == 3:\n        return\n    # \u5c1d\u8bd5\n    path.append(root)\n    if root.val == 7:\n        # \u8bb0\u5f55\u89e3\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # \u56de\u9000\n    path.pop()\n
    preorder_traversal_iii_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode *root) {\n    // \u526a\u679d\n    if (root == nullptr || root->val == 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push_back(root);\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push_back(path);\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n    // \u56de\u9000\n    path.pop_back();\n}\n
    preorder_traversal_iii_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode root) {\n    // \u526a\u679d\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.add(root);\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.add(new ArrayList<>(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // \u56de\u9000\n    path.remove(path.size() - 1);\n}\n
    preorder_traversal_iii_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid PreOrder(TreeNode? root) {\n    // \u526a\u679d\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.Add(root);\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.Add(new List<TreeNode>(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // \u56de\u9000\n    path.RemoveAt(path.Count - 1);\n}\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\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // \u5c1d\u8bd5\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // \u8bb0\u5f55\u89e3\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // \u56de\u9000\n    *path = (*path)[:len(*path)-1]\n}\n
    preorder_traversal_iii_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunc preOrder(root: TreeNode?) {\n    // \u526a\u679d\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // \u5c1d\u8bd5\n    path.append(root)\n    if root.val == 7 {\n        // \u8bb0\u5f55\u89e3\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // \u56de\u9000\n    path.removeLast()\n}\n
    preorder_traversal_iii_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunction preOrder(root, path, res) {\n    // \u526a\u679d\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push(root);\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // \u56de\u9000\n    path.pop();\n}\n
    preorder_traversal_iii_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // \u526a\u679d\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push(root);\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // \u56de\u9000\n    path.pop();\n}\n
    preorder_traversal_iii_compact.dart
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(\n  TreeNode? root,\n  List<TreeNode> path,\n  List<List<TreeNode>> res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // \u5c1d\u8bd5\n  path.add(root);\n  if (root.val == 7) {\n    // \u8bb0\u5f55\u89e3\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // \u56de\u9000\n  path.removeLast();\n}\n
    preorder_traversal_iii_compact.rs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfn pre_order(\n    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,\n    path: &mut Vec<Rc<RefCell<TreeNode>>>,\n    root: Option<Rc<RefCell<TreeNode>>>,\n) {\n    // \u526a\u679d\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // \u5c1d\u8bd5\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // \u8bb0\u5f55\u89e3\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.clone());\n        pre_order(res, path, node.borrow().right.clone());\n        // \u56de\u9000\n        path.remove(path.len() - 1);\n    }\n}\n
    preorder_traversal_iii_compact.c
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode *root) {\n    // \u526a\u679d\n    if (root == NULL || root->val == 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path[pathSize++] = root;\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        for (int i = 0; i < pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n    // \u56de\u9000\n    pathSize--;\n}\n
    preorder_traversal_iii_compact.kt
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfun preOrder(root: TreeNode?) {\n    // \u526a\u679d\n    if (root == null || root.value == 3) {\n        return\n    }\n    // \u5c1d\u8bd5\n    path!!.add(root)\n    if (root.value == 7) {\n        // \u8bb0\u5f55\u89e3\n        res!!.add(ArrayList(path!!))\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // \u56de\u9000\n    path!!.removeAt(path!!.size - 1)\n}\n
    preorder_traversal_iii_compact.rb
    [class]{}-[func]{pre_order}\n
    preorder_traversal_iii_compact.zig
    [class]{}-[func]{preOrder}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u201c\u526a\u679d\u201d\u662f\u4e00\u4e2a\u975e\u5e38\u5f62\u8c61\u7684\u540d\u8bcd\u3002\u5982\u56fe 13-3 \u6240\u793a\uff0c\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6211\u4eec\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\u9ad8\u4e86\u641c\u7d22\u6548\u7387\u3002

    \u56fe 13-3 \u00a0 \u6839\u636e\u7ea6\u675f\u6761\u4ef6\u526a\u679d

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1313","title":"13.1.3 \u00a0 \u6846\u67b6\u4ee3\u7801","text":"

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c1d\u8bd5\u5c06\u56de\u6eaf\u7684\u201c\u5c1d\u8bd5\u3001\u56de\u9000\u3001\u526a\u679d\u201d\u7684\u4e3b\u4f53\u6846\u67b6\u63d0\u70bc\u51fa\u6765\uff0c\u63d0\u5347\u4ee3\u7801\u7684\u901a\u7528\u6027\u3002

    \u5728\u4ee5\u4e0b\u6846\u67b6\u4ee3\u7801\u4e2d\uff0cstate \u8868\u793a\u95ee\u9898\u7684\u5f53\u524d\u72b6\u6001\uff0cchoices \u8868\u793a\u5f53\u524d\u72b6\u6001\u4e0b\u53ef\u4ee5\u505a\u51fa\u7684\u9009\u62e9\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"\u56de\u6eaf\u7b97\u6cd5\u6846\u67b6\"\"\"\n    # \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if is_solution(state):\n        # \u8bb0\u5f55\u89e3\n        record_solution(state, res)\n        # \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices:\n        # \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if is_valid(state, choice):\n            # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undo_choice(state, choice)\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State *state, vector<Choice *> &choices, vector<State *> &res) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (Choice choice : choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice);\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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (Choice choice : choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice);\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\n    if (IsSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        RecordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    foreach (Choice choice in choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (IsValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            UndoChoice(state, choice);\n        }\n    }\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if isSolution(state) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res)\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for _, choice := range choices {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if isValid(state, choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(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\n    if isSolution(state: state) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state: state, res: &res)\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if isValid(state: state, choice: choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state: &state, choice: choice)\n            backtrack(state: &state, choices: choices, res: &res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state: &state, choice: choice)\n        }\n    }\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunction backtrack(state, choices, res) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (let choice of choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (let choice of choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice);\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\n  if (isSolution(state)) {\n    // \u8bb0\u5f55\u89e3\n    recordSolution(state, res);\n    // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (Choice choice in choices) {\n    // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n    if (isValid(state, choice)) {\n      // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n      undoChoice(state, choice);\n    }\n  }\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfn backtrack(state: &mut State, choices: &Vec<Choice>, res: &mut Vec<State>) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if is_solution(state) {\n        // \u8bb0\u5f55\u89e3\n        record_solution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if is_valid(state, choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undo_choice(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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res, numRes);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < numChoices; i++) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, &choices[i])) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, &choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, &choices[i]);\n        }\n    }\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfun backtrack(state: State?, choices: List<Choice?>, res: List<State?>?) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res)\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (choice in choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice)\n        }\n    }\n}\n
    \n
    \n

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u57fa\u4e8e\u6846\u67b6\u4ee3\u7801\u6765\u89e3\u51b3\u4f8b\u9898\u4e09\u3002\u72b6\u6001 state \u4e3a\u8282\u70b9\u904d\u5386\u8def\u5f84\uff0c\u9009\u62e9 choices \u4e3a\u5f53\u524d\u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u548c\u53f3\u5b50\u8282\u70b9\uff0c\u7ed3\u679c res \u662f\u8def\u5f84\u5217\u8868\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig preorder_traversal_iii_template.py
    def is_solution(state: list[TreeNode]) -> bool:\n    \"\"\"\u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"\u8bb0\u5f55\u89e3\"\"\"\n    res.append(list(state))\n\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\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"\u66f4\u65b0\u72b6\u6001\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"\u6062\u590d\u72b6\u6001\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: 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\n    if is_solution(state):\n        # \u8bb0\u5f55\u89e3\n        record_solution(state, res)\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices:\n        # \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if is_valid(state, choice):\n            # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            make_choice(state, choice)\n            # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, [choice.left, choice.right], res)\n            # \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undo_choice(state, choice)\n
    preorder_traversal_iii_template.cpp
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(vector<TreeNode *> &state) {\n    return !state.empty() && state.back()->val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res) {\n    res.push_back(state);\n}\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) {\n    return choice != nullptr && choice->val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(vector<TreeNode *> &state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(vector<TreeNode *> &state, TreeNode *choice) {\n    state.pop_back();\n}\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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (TreeNode *choice : choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            vector<TreeNode *> nextChoices{choice->left, choice->right};\n            backtrack(state, nextChoices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice);\n        }\n    }\n}\n
    preorder_traversal_iii_template.java
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nboolean isSolution(List<TreeNode> state) {\n    return !state.isEmpty() && state.get(state.size() - 1).val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\n    res.add(new ArrayList<>(state));\n}\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) {\n    return choice != null && choice.val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(List<TreeNode> state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(List<TreeNode> state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (TreeNode choice : choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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\n            undoChoice(state, choice);\n        }\n    }\n}\n
    preorder_traversal_iii_template.cs
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool IsSolution(List<TreeNode> state) {\n    return state.Count != 0 && state[^1].val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid RecordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\n    res.Add(new List<TreeNode>(state));\n}\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) {\n    return choice != null && choice.val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid MakeChoice(List<TreeNode> state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid UndoChoice(List<TreeNode> state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\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\n    if (IsSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        RecordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    foreach (TreeNode choice in choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (IsValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            MakeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            UndoChoice(state, choice);\n        }\n    }\n}\n
    preorder_traversal_iii_template.go
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 && (*state)[len(*state)-1].Val == 7\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\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 {\n    return choice != nil && choice.Val != 3\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\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\n    if isSolution(state) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for _, choice := range *choices {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if isValid(state, choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &temp, res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(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\n/* \u8bb0\u5f55\u89e3 */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\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 {\n    choice != nil && choice!.val != 3\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\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\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &res)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if isValid(state: state, choice: choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state: &state, choice: choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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\n            undoChoice(state: &state, choice: choice)\n        }\n    }\n}\n
    preorder_traversal_iii_template.js
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunction isSolution(state) {\n    return state && state[state.length - 1]?.val === 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunction isValid(state, choice) {\n    return choice !== null && choice.val !== 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunction backtrack(state, choices, res) {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (const choice of choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, [choice.left, choice.right], res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(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 {\n    return state && state[state.length - 1]?.val === 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\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 {\n    return choice !== null && choice.val !== 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (const choice of choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, [choice.left, choice.right], res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state);\n        }\n    }\n}\n
    preorder_traversal_iii_template.dart
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(List<TreeNode> state) {\n  return state.isNotEmpty && state.last.val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\n  res.add(List.from(state));\n}\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) {\n  return choice != null && choice.val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(List<TreeNode> state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(List<TreeNode> state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(\n  List<TreeNode> state,\n  List<TreeNode?> choices,\n  List<List<TreeNode>> res,\n) {\n  // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n  if (isSolution(state)) {\n    // \u8bb0\u5f55\u89e3\n    recordSolution(state, res);\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (TreeNode? choice in choices) {\n    // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n    if (isValid(state, choice)) {\n      // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n      makeChoice(state, choice);\n      // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n      backtrack(state, [choice!.left, choice.right], res);\n      // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n      undoChoice(state, choice);\n    }\n  }\n}\n
    preorder_traversal_iii_template.rs
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfn is_solution(state: &mut Vec<Rc<RefCell<TreeNode>>>) -> bool {\n    return !state.is_empty() && state.get(state.len() - 1).unwrap().borrow().val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfn record_solution(\n    state: &mut Vec<Rc<RefCell<TreeNode>>>,\n    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,\n) {\n    res.push(state.clone());\n}\n\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfn is_valid(_: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) -> bool {\n    return choice.borrow().val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfn make_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) {\n    state.push(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfn undo_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, _: Rc<RefCell<TreeNode>>) {\n    state.remove(state.len() - 1);\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfn backtrack(\n    state: &mut Vec<Rc<RefCell<TreeNode>>>,\n    choices: &mut Vec<Rc<RefCell<TreeNode>>>,\n    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,\n) {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if is_solution(state) {\n        // \u8bb0\u5f55\u89e3\n        record_solution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if is_valid(state, choice.clone()) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            make_choice(state, choice.clone());\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(\n                state,\n                &mut vec![\n                    choice.borrow().left.clone().unwrap(),\n                    choice.borrow().right.clone().unwrap(),\n                ],\n                res,\n            );\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undo_choice(state, choice.clone());\n        }\n    }\n}\n
    preorder_traversal_iii_template.c
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(void) {\n    return pathSize > 0 && path[pathSize - 1]->val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(void) {\n    for (int i = 0; i < pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nbool isValid(TreeNode *choice) {\n    return choice != NULL && choice->val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(TreeNode *choices[2]) {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if (isSolution()) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution();\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < 2; i++) {\n        TreeNode *choice = choices[i];\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            TreeNode *nextChoices[2] = {choice->left, choice->right};\n            backtrack(nextChoices);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice();\n        }\n    }\n}\n
    preorder_traversal_iii_template.kt
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfun isSolution(state: List<TreeNode?>): Boolean {\n    return state.isNotEmpty() && state[state.size - 1]?.value == 7\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfun recordSolution(state: MutableList<TreeNode?>?, res: MutableList<List<TreeNode?>?>) {\n    res.add(state?.let { ArrayList(it) })\n}\n\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfun isValid(state: List<TreeNode?>?, choice: TreeNode?): Boolean {\n    return choice != null && choice.value != 3\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfun makeChoice(state: MutableList<TreeNode?>, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfun undoChoice(state: MutableList<TreeNode?>, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfun backtrack(\n    state: MutableList<TreeNode?>,\n    choices: List<TreeNode?>,\n    res: MutableList<List<TreeNode?>?>\n) {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (choice in choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, listOf(choice!!.left, choice.right), res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice)\n        }\n    }\n}\n
    preorder_traversal_iii_template.rb
    [class]{}-[func]{is_solution}\n\n[class]{}-[func]{record_solution}\n\n[class]{}-[func]{is_valid}\n\n[class]{}-[func]{make_choice}\n\n[class]{}-[func]{undo_choice}\n\n[class]{}-[func]{backtrack}\n
    preorder_traversal_iii_template.zig
    [class]{}-[func]{isSolution}\n\n[class]{}-[func]{recordSolution}\n\n[class]{}-[func]{isValid}\n\n[class]{}-[func]{makeChoice}\n\n[class]{}-[func]{undoChoice}\n\n[class]{}-[func]{backtrack}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6839\u636e\u9898\u610f\uff0c\u6211\u4eec\u5728\u627e\u5230\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\u540e\u5e94\u8be5\u7ee7\u7eed\u641c\u7d22\uff0c\u56e0\u6b64\u9700\u8981\u5c06\u8bb0\u5f55\u89e3\u4e4b\u540e\u7684 return \u8bed\u53e5\u5220\u9664\u3002\u56fe 13-4 \u5bf9\u6bd4\u4e86\u4fdd\u7559\u6216\u5220\u9664 return \u8bed\u53e5\u7684\u641c\u7d22\u8fc7\u7a0b\u3002

    \u56fe 13-4 \u00a0 \u4fdd\u7559\u4e0e\u5220\u9664 return \u7684\u641c\u7d22\u8fc7\u7a0b\u5bf9\u6bd4

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

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1314","title":"13.1.4 \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\uff0c\u5982\u8868 13-1 \u6240\u793a\u3002

    \u8868 13-1 \u00a0 \u5e38\u89c1\u7684\u56de\u6eaf\u7b97\u6cd5\u672f\u8bed

    \u540d\u8bcd \u5b9a\u4e49 \u4f8b\u9898\u4e09 \u89e3\uff08solution\uff09 \u89e3\u662f\u6ee1\u8db3\u95ee\u9898\u7279\u5b9a\u6761\u4ef6\u7684\u7b54\u6848\uff0c\u53ef\u80fd\u6709\u4e00\u4e2a\u6216\u591a\u4e2a \u6839\u8282\u70b9\u5230\u8282\u70b9 \\(7\\) \u7684\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\u7684\u6240\u6709\u8def\u5f84 \u7ea6\u675f\u6761\u4ef6\uff08constraint\uff09 \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 \u8def\u5f84\u4e2d\u4e0d\u5305\u542b\u8282\u70b9 \\(3\\) \u72b6\u6001\uff08state\uff09 \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 \u5c1d\u8bd5\uff08attempt\uff09 \u5c1d\u8bd5\u662f\u6839\u636e\u53ef\u7528\u9009\u62e9\u6765\u63a2\u7d22\u89e3\u7a7a\u95f4\u7684\u8fc7\u7a0b\uff0c\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\uff08backtracking\uff09 \u56de\u9000\u6307\u9047\u5230\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\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\u8282\u70b9\u3001\u7ed3\u675f\u8282\u70b9\u8bbf\u95ee\u3001\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u65f6\u7ec8\u6b62\u641c\u7d22\uff0c\u51fd\u6570\u8fd4\u56de \u526a\u679d\uff08pruning\uff09 \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\u4e0d\u518d\u7ee7\u7eed\u641c\u7d22

    Tip

    \u95ee\u9898\u3001\u89e3\u3001\u72b6\u6001\u7b49\u6982\u5ff5\u662f\u901a\u7528\u7684\uff0c\u5728\u5206\u6cbb\u3001\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\u3001\u8d2a\u5fc3\u7b49\u7b97\u6cd5\u4e2d\u90fd\u6709\u6d89\u53ca\u3002

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1315","title":"13.1.5 \u00a0 \u4f18\u70b9\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\u70b9\u5728\u4e8e\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

    • \u65f6\u95f4\uff1a\u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u9700\u8981\u904d\u5386\u72b6\u6001\u7a7a\u95f4\u7684\u6240\u6709\u53ef\u80fd\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u8fbe\u5230\u6307\u6570\u9636\u6216\u9636\u4e58\u9636\u3002
    • \u7a7a\u95f4\uff1a\u5728\u9012\u5f52\u8c03\u7528\u4e2d\u9700\u8981\u4fdd\u5b58\u5f53\u524d\u7684\u72b6\u6001\uff08\u4f8b\u5982\u8def\u5f84\u3001\u7528\u4e8e\u526a\u679d\u7684\u8f85\u52a9\u53d8\u91cf\u7b49\uff09\uff0c\u5f53\u6df1\u5ea6\u5f88\u5927\u65f6\uff0c\u7a7a\u95f4\u9700\u6c42\u53ef\u80fd\u4f1a\u53d8\u5f97\u5f88\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\u4f18\u5316\u6548\u7387\uff0c\u5e38\u89c1\u7684\u6548\u7387\u4f18\u5316\u65b9\u6cd5\u6709\u4e24\u79cd\u3002

    • \u526a\u679d\uff1a\u907f\u514d\u641c\u7d22\u90a3\u4e9b\u80af\u5b9a\u4e0d\u4f1a\u4ea7\u751f\u89e3\u7684\u8def\u5f84\uff0c\u4ece\u800c\u8282\u7701\u65f6\u95f4\u548c\u7a7a\u95f4\u3002
    • \u542f\u53d1\u5f0f\u641c\u7d22\uff1a\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/#1316","title":"13.1.6 \u00a0 \u56de\u6eaf\u5178\u578b\u4f8b\u9898","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

    \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\u6839\u67f1\u5b50\u548c\u4e00\u7cfb\u5217\u5927\u5c0f\u4e0d\u540c\u7684\u5706\u76d8\uff0c\u8981\u6c42\u5c06\u6240\u6709\u5706\u76d8\u4ece\u4e00\u6839\u67f1\u5b50\u79fb\u52a8\u5230\u53e6\u4e00\u6839\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\u5bf9\u4e8e\u8bb8\u591a\u7ec4\u5408\u4f18\u5316\u95ee\u9898\uff0c\u56de\u6eaf\u4e0d\u662f\u6700\u4f18\u89e3\u51b3\u65b9\u6848\u3002

    • 0-1 \u80cc\u5305\u95ee\u9898\u901a\u5e38\u4f7f\u7528\u52a8\u6001\u89c4\u5212\u89e3\u51b3\uff0c\u4ee5\u8fbe\u5230\u66f4\u9ad8\u7684\u65f6\u95f4\u6548\u7387\u3002
    • \u65c5\u884c\u5546\u662f\u4e00\u4e2a\u8457\u540d\u7684 NP-Hard \u95ee\u9898\uff0c\u5e38\u7528\u89e3\u6cd5\u6709\u9057\u4f20\u7b97\u6cd5\u548c\u8681\u7fa4\u7b97\u6cd5\u7b49\u3002
    • \u6700\u5927\u56e2\u95ee\u9898\u662f\u56fe\u8bba\u4e2d\u7684\u4e00\u4e2a\u7ecf\u5178\u95ee\u9898\uff0c\u53ef\u7528\u8d2a\u5fc3\u7b97\u6cd5\u7b49\u542f\u53d1\u5f0f\u7b97\u6cd5\u6765\u89e3\u51b3\u3002
    "},{"location":"chapter_backtracking/n_queens_problem/","title":"13.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\u540c\u5904\u4e00\u884c\u3001\u4e00\u5217\u6216\u4e00\u6761\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\u56fe 13-15 \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

    \u56fe 13-15 \u00a0 4 \u7687\u540e\u95ee\u9898\u7684\u89e3

    \u56fe 13-16 \u5c55\u793a\u4e86\u672c\u9898\u7684\u4e09\u4e2a\u7ea6\u675f\u6761\u4ef6\uff1a\u591a\u4e2a\u7687\u540e\u4e0d\u80fd\u5728\u540c\u4e00\u884c\u3001\u540c\u4e00\u5217\u3001\u540c\u4e00\u6761\u5bf9\u89d2\u7ebf\u4e0a\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u5bf9\u89d2\u7ebf\u5206\u4e3a\u4e3b\u5bf9\u89d2\u7ebf \\ \u548c\u6b21\u5bf9\u89d2\u7ebf / \u4e24\u79cd\u3002

    \u56fe 13-16 \u00a0 n \u7687\u540e\u95ee\u9898\u7684\u7ea6\u675f\u6761\u4ef6

    "},{"location":"chapter_backtracking/n_queens_problem/#1","title":"1. \u00a0 \u9010\u884c\u653e\u7f6e\u7b56\u7565","text":"

    \u7687\u540e\u7684\u6570\u91cf\u548c\u68cb\u76d8\u7684\u884c\u6570\u90fd\u4e3a \\(n\\) \uff0c\u56e0\u6b64\u6211\u4eec\u5bb9\u6613\u5f97\u5230\u4e00\u4e2a\u63a8\u8bba\uff1a\u68cb\u76d8\u6bcf\u884c\u90fd\u5141\u8bb8\u4e14\u53ea\u5141\u8bb8\u653e\u7f6e\u4e00\u4e2a\u7687\u540e\u3002

    \u4e5f\u5c31\u662f\u8bf4\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

    \u56fe 13-17 \u6240\u793a\u4e3a \\(4\\) \u7687\u540e\u95ee\u9898\u7684\u9010\u884c\u653e\u7f6e\u8fc7\u7a0b\u3002\u53d7\u753b\u5e45\u9650\u5236\uff0c\u56fe 13-17 \u4ec5\u5c55\u5f00\u4e86\u7b2c\u4e00\u884c\u7684\u5176\u4e2d\u4e00\u4e2a\u641c\u7d22\u5206\u652f\uff0c\u5e76\u4e14\u5c06\u4e0d\u6ee1\u8db3\u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u65b9\u6848\u90fd\u8fdb\u884c\u4e86\u526a\u679d\u3002

    \u56fe 13-17 \u00a0 \u9010\u884c\u653e\u7f6e\u7b56\u7565

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u9010\u884c\u653e\u7f6e\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

    "},{"location":"chapter_backtracking/n_queens_problem/#2","title":"2. \u00a0 \u5217\u4e0e\u5bf9\u89d2\u7ebf\u526a\u679d","text":"

    \u4e3a\u4e86\u6ee1\u8db3\u5217\u7ea6\u675f\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\u8fdb\u884c\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\u9009\u5b9a\u77e9\u9635\u4e2d\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\u90fd\u76f8\u7b49\uff0c\u5373\u5bf9\u89d2\u7ebf\u4e0a\u6240\u6709\u683c\u5b50\u7684 \\(row - col\\) \u4e3a\u6052\u5b9a\u503c\u3002

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5982\u679c\u4e24\u4e2a\u683c\u5b50\u6ee1\u8db3 \\(row_1 - col_1 = row_2 - col_2\\) \uff0c\u5219\u5b83\u4eec\u4e00\u5b9a\u5904\u5728\u540c\u4e00\u6761\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u3002\u5229\u7528\u8be5\u89c4\u5f8b\uff0c\u6211\u4eec\u53ef\u4ee5\u501f\u52a9\u56fe 13-18 \u6240\u793a\u7684\u6570\u7ec4 diags1 \u8bb0\u5f55\u6bcf\u6761\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\u3002

    \u540c\u7406\uff0c\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u7684\u6240\u6709\u683c\u5b50\u7684 \\(row + col\\) \u662f\u6052\u5b9a\u503c\u3002\u6211\u4eec\u540c\u6837\u4e5f\u53ef\u4ee5\u501f\u52a9\u6570\u7ec4 diags2 \u6765\u5904\u7406\u6b21\u5bf9\u89d2\u7ebf\u7ea6\u675f\u3002

    \u56fe 13-18 \u00a0 \u5904\u7406\u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f

    "},{"location":"chapter_backtracking/n_queens_problem/#3","title":"3. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u8bf7\u6ce8\u610f\uff0c\\(n\\) \u7ef4\u65b9\u9635\u4e2d \\(row - col\\) \u7684\u8303\u56f4\u662f \\([-n + 1, n - 1]\\) \uff0c\\(row + col\\) \u7684\u8303\u56f4\u662f \\([0, 2n - 2]\\) \uff0c\u6240\u4ee5\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\u7684\u6570\u91cf\u90fd\u4e3a \\(2n - 1\\) \uff0c\u5373\u6570\u7ec4 diags1 \u548c diags2 \u7684\u957f\u5ea6\u90fd\u4e3a \\(2n - 1\\) \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig n_queens.py
    def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e\"\"\"\n    # \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # \u904d\u5386\u6240\u6709\u5217\n    for col in range(n):\n        # \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if not cols[col] and not diags1[diag1] and not 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\n            # \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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\n\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\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    diags1 = [False] * (2 * n - 1)  # \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    diags2 = [False] * (2 * n - 1)  # \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\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,\n               vector<bool> &diags1, vector<bool> &diags2) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (int col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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;\n        }\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\n    vector<vector<string>> state(n, vector<string>(n, \"#\"));\n    vector<bool> cols(n, false);           // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    vector<bool> diags1(2 * n - 1, false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    vector<bool> diags2(2 * n - 1, false); // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    vector<vector<vector<string>>> res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n
    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,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        List<List<String>> copyState = new ArrayList<>();\n        for (List<String> sRow : state) {\n            copyState.add(new ArrayList<>(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (int col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n            // \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\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\n    List<List<String>> state = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        List<String> row = new ArrayList<>();\n        for (int j = 0; j < n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    boolean[] diags1 = new boolean[2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    boolean[] diags2 = new boolean[2 * n - 1]; // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    List<List<List<String>>> res = new ArrayList<>();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\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,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        List<List<string>> copyState = [];\n        foreach (List<string> sRow in state) {\n            copyState.Add(new List<string>(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (int col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            Backtrack(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;\n        }\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\n    List<List<string>> state = [];\n    for (int i = 0; i < n; i++) {\n        List<string> row = [];\n        for (int j = 0; j < n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    bool[] diags1 = new bool[2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    bool[] diags2 = new bool[2 * n - 1]; // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    List<List<List<string>>> res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\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\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for col := 0; col < n; col++ {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if !(*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\n            backtrack(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\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\n    state := make([][]string, n)\n    for i := 0; i < n; i++ {\n        row := make([]string, n)\n        for i := 0; i < n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &state, &res, &cols, &diags1, &diags2)\n    return 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\n    if row == n {\n        res.append(state)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for col in 0 ..< n {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if !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] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\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\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)\n\n    return 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\n    if (row === n) {\n        res.push(state.map((row) => row.slice()));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (let col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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;\n        }\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\n    const state = Array.from({ length: n }, () => Array(n).fill('#'));\n    const cols = Array(n).fill(false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    const diags1 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    const diags2 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n
    n_queens.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row === n) {\n        res.push(state.map((row) => row.slice()));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (let col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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;\n        }\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\n    const state = Array.from({ length: n }, () => Array(n).fill('#'));\n    const cols = Array(n).fill(false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    const diags1 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    const diags2 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n
    n_queens.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nvoid backtrack(\n  int row,\n  int n,\n  List<List<String>> state,\n  List<List<List<String>>> res,\n  List<bool> cols,\n  List<bool> diags1,\n  List<bool> diags2,\n) {\n  // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (row == n) {\n    List<List<String>> copyState = [];\n    for (List<String> sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u5217\n  for (int col = 0; col < n; col++) {\n    // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n    if (!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] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // \u653e\u7f6e\u4e0b\u4e00\u884c\n      backtrack(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] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\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\n  List<List<String>> state = List.generate(n, (index) => List.filled(n, \"#\"));\n  List<bool> cols = List.filled(n, false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n  List<bool> diags1 = List.filled(2 * n - 1, false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n  List<bool> diags2 = List.filled(2 * n - 1, false); // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n  List<List<List<String>>> res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n
    n_queens.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &mut Vec<Vec<String>>,\n    res: &mut Vec<Vec<Vec<String>>>,\n    cols: &mut [bool],\n    diags1: &mut [bool],\n    diags2: &mut [bool],\n) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if row == n {\n        let mut copy_state: Vec<Vec<String>> = Vec::new();\n        for s_row in state.clone() {\n            copy_state.push(s_row);\n        }\n        res.push(copy_state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for col in 0..n {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if !cols[col] && !diags1[diag1] && !diags2[diag2] {\n            // \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\n            state.get_mut(row).unwrap()[col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\n            state.get_mut(row).unwrap()[col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* \u6c42\u89e3 n \u7687\u540e */\nfn n_queens(n: usize) -> Vec<Vec<Vec<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\n    let mut state: Vec<Vec<String>> = Vec::new();\n    for _ in 0..n {\n        let mut row: Vec<String> = Vec::new();\n        for _ in 0..n {\n            row.push(\"#\".into());\n        }\n        state.push(row);\n    }\n    let mut cols = vec![false; n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    let mut diags1 = vec![false; 2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    let mut diags2 = vec![false; 2 * n - 1]; // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    let mut res: Vec<Vec<Vec<String>>> = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &mut state,\n        &mut res,\n        &mut cols,\n        &mut diags1,\n        &mut diags2,\n    );\n\n    res\n}\n
    n_queens.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i < n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (int col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(row + 1, n, state, res, resSize, 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;\n        }\n    }\n}\n\n/* \u6c42\u89e3 n \u7687\u540e */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\n    for (int i = 0; i < n; ++i) {\n        for (int j = 0; j < n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n
    n_queens.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: List<MutableList<String>>,\n    res: MutableList<List<List<String>>?>,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        val copyState: MutableList<List<String>> = ArrayList()\n        for (sRow in state) {\n            copyState.add(ArrayList(sRow))\n        }\n        res.add(copyState)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (col in 0..<n) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* \u6c42\u89e3 n \u7687\u540e */\nfun nQueens(n: Int): List<List<List<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\n    val state: MutableList<MutableList<String>> = ArrayList()\n    for (i in 0..<n) {\n        val row: MutableList<String> = ArrayList()\n        for (j in 0..<n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    val diags1 = BooleanArray(2 * n - 1) // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    val diags2 = BooleanArray(2 * n - 1) // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    val res: MutableList<List<List<String>>?> = ArrayList()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n
    n_queens.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{n_queens}\n
    n_queens.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{nQueens}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\\)\u3001\\(n-1\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \u4e2a\u9009\u62e9\uff0c\u4f7f\u7528 \\(O(n!)\\) \u65f6\u95f4\u3002\u5f53\u8bb0\u5f55\u89e3\u65f6\uff0c\u9700\u8981\u590d\u5236\u77e9\u9635 state \u5e76\u6dfb\u52a0\u8fdb res \uff0c\u590d\u5236\u64cd\u4f5c\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002\u56e0\u6b64\uff0c\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n! \\cdot n^2)\\) \u3002\u5b9e\u9645\u4e0a\uff0c\u6839\u636e\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u526a\u679d\u4e5f\u80fd\u591f\u5927\u5e45\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

    \u6570\u7ec4 state \u4f7f\u7528 \\(O(n^2)\\) \u7a7a\u95f4\uff0c\u6570\u7ec4 cols\u3001diags1 \u548c 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":"13.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\u5176\u4e2d\u5143\u7d20\u7684\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u3002

    \u8868 13-2 \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

    \u8868 13-2 \u00a0 \u5168\u6392\u5217\u793a\u4f8b

    \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/#1321","title":"13.2.1 \u00a0 \u65e0\u76f8\u7b49\u5143\u7d20\u7684\u60c5\u51b5","text":"

    Question

    \u8f93\u5165\u4e00\u4e2a\u6574\u6570\u6570\u7ec4\uff0c\u5176\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\\) \uff0c\u518d\u9009\u62e9 \\(3\\) \uff0c\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\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\u8bf7\u6ce8\u610f\uff0c\u6bcf\u4e2a\u5143\u7d20\u53ea\u5141\u8bb8\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u56e0\u6b64 state \u4e2d\u7684\u6240\u6709\u5143\u7d20\u90fd\u5e94\u8be5\u662f\u552f\u4e00\u7684\u3002

    \u5982\u56fe 13-5 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u641c\u7d22\u8fc7\u7a0b\u5c55\u5f00\u6210\u4e00\u68f5\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

    \u56fe 13-5 \u00a0 \u5168\u6392\u5217\u7684\u9012\u5f52\u6811

    "},{"location":"chapter_backtracking/permutations_problem/#1","title":"1. \u00a0 \u91cd\u590d\u9009\u62e9\u526a\u679d","text":"

    \u4e3a\u4e86\u5b9e\u73b0\u6bcf\u4e2a\u5143\u7d20\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u6211\u4eec\u8003\u8651\u5f15\u5165\u4e00\u4e2a\u5e03\u5c14\u578b\u6570\u7ec4 selected \uff0c\u5176\u4e2d selected[i] \u8868\u793a choices[i] \u662f\u5426\u5df2\u88ab\u9009\u62e9\uff0c\u5e76\u57fa\u4e8e\u5b83\u5b9e\u73b0\u4ee5\u4e0b\u526a\u679d\u64cd\u4f5c\u3002

    • \u5728\u505a\u51fa\u9009\u62e9 choice[i] \u540e\uff0c\u6211\u4eec\u5c31\u5c06 selected[i] \u8d4b\u503c\u4e3a \\(\\text{True}\\) \uff0c\u4ee3\u8868\u5b83\u5df2\u88ab\u9009\u62e9\u3002
    • \u904d\u5386\u9009\u62e9\u5217\u8868 choices \u65f6\uff0c\u8df3\u8fc7\u6240\u6709\u5df2\u88ab\u9009\u62e9\u7684\u8282\u70b9\uff0c\u5373\u526a\u679d\u3002

    \u5982\u56fe 13-6 \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 \u548c\u5143\u7d20 3 \u7684\u5206\u652f\u3002

    \u56fe 13-6 \u00a0 \u5168\u6392\u5217\u526a\u679d\u793a\u4f8b

    \u89c2\u5bdf\u56fe 13-6 \u53d1\u73b0\uff0c\u8be5\u526a\u679d\u64cd\u4f5c\u5c06\u641c\u7d22\u7a7a\u95f4\u5927\u5c0f\u4ece \\(O(n^n)\\) \u51cf\u5c0f\u81f3 \\(O(n!)\\) \u3002

    "},{"location":"chapter_backtracking/permutations_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \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\u6574\u4f53\u4ee3\u7801\uff0c\u6211\u4eec\u4e0d\u5355\u72ec\u5b9e\u73b0\u6846\u67b6\u4ee3\u7801\u4e2d\u7684\u5404\u4e2a\u51fd\u6570\uff0c\u800c\u662f\u5c06\u5b83\u4eec\u5c55\u5f00\u5728 backtrack() \u51fd\u6570\u4e2d\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig permutations_i.py
    def backtrack(\n    state: 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\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i, choice in enumerate(choices):\n        # \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if not selected[i]:\n            # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = True\n            state.append(choice)\n            # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop()\n\ndef permutations_i(nums: list[int]) -> list[list[int]]:\n    \"\"\"\u5168\u6392\u5217 I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\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\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choices.size(); i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.push_back(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop_back();\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nvector<vector<int>> permutationsI(vector<int> nums) {\n    vector<int> state;\n    vector<bool> selected(nums.size(), false);\n    vector<vector<int>> res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n
    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\n    if (state.size() == choices.length) {\n        res.add(new ArrayList<Integer>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choices.length; i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.add(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.remove(state.size() - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nList<List<Integer>> permutationsI(int[] nums) {\n    List<List<Integer>> res = new ArrayList<List<Integer>>();\n    backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);\n    return res;\n}\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\n    if (state.Count == choices.Length) {\n        res.Add(new List<int>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choices.Length; i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.Add(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            Backtrack(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.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nList<List<int>> PermutationsI(int[] nums) {\n    List<List<int>> res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\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\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i := 0; i < len(*choices); i++ {\n        choice := (*choices)[i]\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if !(*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\n            backtrackI(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\n/* \u5168\u6392\u5217 I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&state, &nums, &selected, &res)\n    return 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\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (i, choice) in choices.enumerated() {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if !selected[i] {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true\n            state.append(choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nfunc permutationsI(nums: [Int]) -> [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &state, choices: nums, selected: &selected, res: &res)\n    return 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\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    choices.forEach((choice, i) => {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop();\n        }\n    });\n}\n\n/* \u5168\u6392\u5217 I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n
    permutations_i.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    choices.forEach((choice, i) => {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop();\n        }\n    });\n}\n\n/* \u5168\u6392\u5217 I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n
    permutations_i.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(\n  List<int> state,\n  List<int> choices,\n  List<bool> selected,\n  List<List<int>> res,\n) {\n  // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (int i = 0; i < choices.length; i++) {\n    int choice = choices[i];\n    // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n    if (!selected[i]) {\n      // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n      selected[i] = true;\n      state.add(choice);\n      // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n      backtrack(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.removeLast();\n    }\n  }\n}\n\n/* \u5168\u6392\u5217 I */\nList<List<int>> permutationsI(List<int> nums) {\n  List<List<int>> res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n
    permutations_i.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfn backtrack(mut state: Vec<i32>, choices: &[i32], selected: &mut [bool], res: &mut Vec<Vec<i32>>) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if !selected[i] {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state.clone(), 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.remove(state.len() - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nfn permutations_i(nums: &mut [i32]) -> Vec<Vec<i32>> {\n    let mut res = Vec::new(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);\n    res\n}\n
    permutations_i.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i < choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choicesSize; i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state[stateSize] = choice;\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            selected[i] = false;\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i < numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n
    permutations_i.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfun backtrack(\n    state: MutableList<Int>,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList<List<Int>?>\n) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (state.size == choices.size) {\n        res.add(ArrayList(state))\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true\n            state.add(choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nfun permutationsI(nums: IntArray): List<List<Int>?> {\n    val res: MutableList<List<Int>?> = ArrayList()\n    backtrack(ArrayList(), nums, BooleanArray(nums.size), res)\n    return res\n}\n
    permutations_i.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{permutations_i}\n
    permutations_i.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{permutationsI}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_backtracking/permutations_problem/#1322","title":"13.2.2 \u00a0 \u8003\u8651\u76f8\u7b49\u5143\u7d20\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\u5143\u7d20 \\(1\\) \uff0c\u6211\u4eec\u5c06\u7b2c\u4e8c\u4e2a \\(1\\) \u8bb0\u4e3a \\(\\hat{1}\\) \u3002

    \u5982\u56fe 13-7 \u6240\u793a\uff0c\u4e0a\u8ff0\u65b9\u6cd5\u751f\u6210\u7684\u6392\u5217\u6709\u4e00\u534a\u662f\u91cd\u590d\u7684\u3002

    \u56fe 13-7 \u00a0 \u91cd\u590d\u6392\u5217

    \u90a3\u4e48\u5982\u4f55\u53bb\u9664\u91cd\u590d\u7684\u6392\u5217\u5462\uff1f\u6700\u76f4\u63a5\u5730\uff0c\u8003\u8651\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\u6ca1\u6709\u5fc5\u8981\uff0c\u5e94\u5f53\u63d0\u524d\u8bc6\u522b\u5e76\u526a\u679d\uff0c\u8fd9\u6837\u53ef\u4ee5\u8fdb\u4e00\u6b65\u63d0\u5347\u7b97\u6cd5\u6548\u7387\u3002

    "},{"location":"chapter_backtracking/permutations_problem/#1_1","title":"1. \u00a0 \u76f8\u7b49\u5143\u7d20\u526a\u679d","text":"

    \u89c2\u5bdf\u56fe 13-8 \uff0c\u5728\u7b2c\u4e00\u8f6e\u4e2d\uff0c\u9009\u62e9 \\(1\\) \u6216\u9009\u62e9 \\(\\hat{1}\\) \u662f\u7b49\u4ef7\u7684\uff0c\u5728\u8fd9\u4e24\u4e2a\u9009\u62e9\u4e4b\u4e0b\u751f\u6210\u7684\u6240\u6709\u6392\u5217\u90fd\u662f\u91cd\u590d\u7684\u3002\u56e0\u6b64\u5e94\u8be5\u628a \\(\\hat{1}\\) \u526a\u679d\u3002

    \u540c\u7406\uff0c\u5728\u7b2c\u4e00\u8f6e\u9009\u62e9 \\(2\\) \u4e4b\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\u5e94\u5c06\u7b2c\u4e8c\u8f6e\u7684 \\(\\hat{1}\\) \u526a\u679d\u3002

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u6211\u4eec\u7684\u76ee\u6807\u662f\u5728\u67d0\u4e00\u8f6e\u9009\u62e9\u4e2d\uff0c\u4fdd\u8bc1\u591a\u4e2a\u76f8\u7b49\u7684\u5143\u7d20\u4ec5\u88ab\u9009\u62e9\u4e00\u6b21\u3002

    \u56fe 13-8 \u00a0 \u91cd\u590d\u6392\u5217\u526a\u679d

    "},{"location":"chapter_backtracking/permutations_problem/#2_1","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig permutations_ii.py
    def backtrack(\n    state: 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\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    duplicated = set[int]()\n    for 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\n        if not selected[i] and choice not in duplicated:\n            # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice)  # \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = True\n            state.append(choice)\n            # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop()\n\ndef permutations_ii(nums: list[int]) -> list[list[int]]:\n    \"\"\"\u5168\u6392\u5217 II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\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\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    unordered_set<int> duplicated;\n    for (int i = 0; i < choices.size(); i++) {\n        int 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\n        if (!selected[i] && duplicated.find(choice) == duplicated.end()) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.emplace(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.push_back(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop_back();\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nvector<vector<int>> permutationsII(vector<int> nums) {\n    vector<int> state;\n    vector<bool> selected(nums.size(), false);\n    vector<vector<int>> res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n
    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\n    if (state.size() == choices.length) {\n        res.add(new ArrayList<Integer>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    Set<Integer> duplicated = new HashSet<Integer>();\n    for (int i = 0; i < choices.length; i++) {\n        int 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\n        if (!selected[i] && !duplicated.contains(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.add(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.remove(state.size() - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nList<List<Integer>> permutationsII(int[] nums) {\n    List<List<Integer>> res = new ArrayList<List<Integer>>();\n    backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);\n    return res;\n}\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\n    if (state.Count == choices.Length) {\n        res.Add(new List<int>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    HashSet<int> duplicated = [];\n    for (int i = 0; i < choices.Length; i++) {\n        int 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\n        if (!selected[i] && !duplicated.Contains(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.Add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.Add(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            Backtrack(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.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nList<List<int>> PermutationsII(int[] nums) {\n    List<List<int>> res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\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\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i < len(*choices); i++ {\n        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\n        if _, 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\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrackI(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\n/* \u5168\u6392\u5217 II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&state, &nums, &selected, &res)\n    return 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\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    var duplicated: Set<Int> = []\n    for (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\n        if !selected[i], !duplicated.contains(choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.insert(choice) // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true\n            state.append(choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nfunc permutationsII(nums: [Int]) -> [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &state, choices: nums, selected: &selected, res: &res)\n    return 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\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    const duplicated = new Set();\n    choices.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\n        if (!selected[i] && !duplicated.has(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop();\n        }\n    });\n}\n\n/* \u5168\u6392\u5217 II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n
    permutations_ii.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    const duplicated = new Set();\n    choices.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\n        if (!selected[i] && !duplicated.has(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop();\n        }\n    });\n}\n\n/* \u5168\u6392\u5217 II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n
    permutations_ii.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(\n  List<int> state,\n  List<int> choices,\n  List<bool> selected,\n  List<List<int>> res,\n) {\n  // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  Set<int> duplicated = {};\n  for (int i = 0; i < choices.length; i++) {\n    int 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\n    if (!selected[i] && !duplicated.contains(choice)) {\n      // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n      duplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n      selected[i] = true;\n      state.add(choice);\n      // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n      backtrack(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.removeLast();\n    }\n  }\n}\n\n/* \u5168\u6392\u5217 II */\nList<List<int>> permutationsII(List<int> nums) {\n  List<List<int>> res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n
    permutations_ii.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfn backtrack(mut state: Vec<i32>, choices: &[i32], selected: &mut [bool], res: &mut Vec<Vec<i32>>) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    let mut duplicated = HashSet::<i32>::new();\n    for i in 0..choices.len() {\n        let 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\n        if !selected[i] && !duplicated.contains(&choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.insert(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state.clone(), 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.remove(state.len() - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nfn permutations_ii(nums: &mut [i32]) -> Vec<Vec<i32>> {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);\n    res\n}\n
    permutations_ii.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i < choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i < choicesSize; i++) {\n        int 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\n        if (!selected[i] && !duplicated[choice]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated[choice] = true; // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state[stateSize] = choice;\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            selected[i] = false;\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i < numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n
    permutations_ii.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfun backtrack(\n    state: MutableList<Int>,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList<MutableList<Int>?>\n) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (state.size == choices.size) {\n        res.add(ArrayList(state))\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    val duplicated: MutableSet<Int> = HashSet()\n    for (i in choices.indices) {\n        val 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\n        if (!selected[i] && !duplicated.contains(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice) // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true\n            state.add(choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nfun permutationsII(nums: IntArray): MutableList<MutableList<Int>?> {\n    val res: MutableList<MutableList<Int>?> = ArrayList()\n    backtrack(ArrayList(), nums, BooleanArray(nums.size), res)\n    return res\n}\n
    permutations_ii.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{permutations_ii}\n
    permutations_ii.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{permutationsII}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\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\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_backtracking/permutations_problem/#3","title":"3. \u00a0 \u4e24\u79cd\u526a\u679d\u5bf9\u6bd4","text":"

    \u8bf7\u6ce8\u610f\uff0c\u867d\u7136 selected \u548c duplicated \u90fd\u7528\u4e8e\u526a\u679d\uff0c\u4f46\u4e24\u8005\u7684\u76ee\u6807\u4e0d\u540c\u3002

    • \u91cd\u590d\u9009\u62e9\u526a\u679d\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\u5176\u4f5c\u7528\u662f\u907f\u514d\u67d0\u4e2a\u5143\u7d20\u5728 state \u4e2d\u91cd\u590d\u51fa\u73b0\u3002
    • \u76f8\u7b49\u5143\u7d20\u526a\u679d\uff1a\u6bcf\u8f6e\u9009\u62e9\uff08\u6bcf\u4e2a\u8c03\u7528\u7684 backtrack \u51fd\u6570\uff09\u90fd\u5305\u542b\u4e00\u4e2a duplicated \u3002\u5b83\u8bb0\u5f55\u7684\u662f\u5728\u672c\u8f6e\u904d\u5386\uff08for \u5faa\u73af\uff09\u4e2d\u54ea\u4e9b\u5143\u7d20\u5df2\u88ab\u9009\u62e9\u8fc7\uff0c\u5176\u4f5c\u7528\u662f\u4fdd\u8bc1\u76f8\u7b49\u5143\u7d20\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\u3002

    \u56fe 13-9 \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

    \u56fe 13-9 \u00a0 \u4e24\u79cd\u526a\u679d\u6761\u4ef6\u7684\u4f5c\u7528\u8303\u56f4

    "},{"location":"chapter_backtracking/subset_sum_problem/","title":"13.3 \u00a0 \u5b50\u96c6\u548c\u95ee\u9898","text":""},{"location":"chapter_backtracking/subset_sum_problem/#1331","title":"13.3.1 \u00a0 \u65e0\u91cd\u590d\u5143\u7d20\u7684\u60c5\u51b5","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\u89e3\u4e3a \\(\\{3, 3, 3\\}, \\{4, 5\\}\\) \u3002\u9700\u8981\u6ce8\u610f\u4ee5\u4e0b\u4e24\u70b9\u3002

    • \u8f93\u5165\u96c6\u5408\u4e2d\u7684\u5143\u7d20\u53ef\u4ee5\u88ab\u65e0\u9650\u6b21\u91cd\u590d\u9009\u53d6\u3002
    • \u5b50\u96c6\u4e0d\u533a\u5206\u5143\u7d20\u987a\u5e8f\uff0c\u6bd4\u5982 \\(\\{4, 5\\}\\) \u548c \\(\\{5, 4\\}\\) \u662f\u540c\u4e00\u4e2a\u5b50\u96c6\u3002
    "},{"location":"chapter_backtracking/subset_sum_problem/#1","title":"1. \u00a0 \u53c2\u8003\u5168\u6392\u5217\u89e3\u6cd5","text":"

    \u7c7b\u4f3c\u4e8e\u5168\u6392\u5217\u95ee\u9898\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\u96c6\u5408\u4e2d\u7684\u5143\u7d20\u53ef\u4ee5\u88ab\u65e0\u9650\u6b21\u9009\u53d6\uff0c\u56e0\u6b64\u65e0\u987b\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig subset_sum_i_naive.py
    def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    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\n    if total == target:\n        res.append(list(state))\n        return\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i in range(len(choices)):\n        # \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if total + choices[i] > target:\n            continue\n        # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.append(choices[i])\n        # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res)\n        # \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop()\n\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\"\"\"\n    state = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    total = 0  # \u5b50\u96c6\u548c\n    res = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res)\n    return res\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\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (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\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.push_back(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop_back();\n    }\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) {\n    vector<int> state;       // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    int total = 0;           // \u5b50\u96c6\u548c\n    vector<vector<int>> res; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n
    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\n    if (total == target) {\n        res.add(new ArrayList<>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (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\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.remove(state.size() - 1);\n    }\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) {\n    List<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    int total = 0; // \u5b50\u96c6\u548c\n    List<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res);\n    return res;\n}\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\n    if (total == target) {\n        res.Add(new List<int>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (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\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.Add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        Backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.RemoveAt(state.Count - 1);\n    }\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) {\n    List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    int total = 0; // \u5b50\u96c6\u548c\n    List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\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\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i := 0; i < len(*choices); i++ {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if total+(*choices)[i] > target {\n            continue\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\n        backtrackSubsetSumINaive(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\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    total := 0              // \u5b50\u96c6\u548c\n    res := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrackSubsetSumINaive(total, target, &state, &nums, &res)\n    return 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\n    if total == target {\n        res.append(state)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i in choices.indices {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if total + choices[i] > target {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.append(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.removeLast()\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunc subsetSumINaive(nums: [Int], target: Int) -> [[Int]] {\n    var state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    let total = 0 // \u5b50\u96c6\u548c\n    var res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state: &state, target: target, total: total, choices: nums, res: &res)\n    return res\n}\n
    subset_sum_i_naive.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunction backtrack(state, target, total, choices, res) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (let i = 0; i < choices.length; i++) {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    const total = 0; // \u5b50\u96c6\u548c\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n
    subset_sum_i_naive.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (let i = 0; i < choices.length; i++) {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    const total = 0; // \u5b50\u96c6\u548c\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n
    subset_sum_i_naive.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(\n  List<int> state,\n  int target,\n  int total,\n  List<int> choices,\n  List<List<int>> res,\n) {\n  // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (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\n    if (total + choices[i] > target) {\n      continue;\n    }\n    // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n    state.add(choices[i]);\n    // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n    backtrack(state, target, total + choices[i], choices, res);\n    // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n    state.removeLast();\n  }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nList<List<int>> subsetSumINaive(List<int> nums, int target) {\n  List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n  int total = 0; // \u5143\u7d20\u548c\n  List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n
    subset_sum_i_naive.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfn backtrack(\n    mut state: Vec<i32>,\n    target: i32,\n    total: i32,\n    choices: &[i32],\n    res: &mut Vec<Vec<i32>>,\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if total == target {\n        res.push(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i in 0..choices.len() {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if total + choices[i] > target {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state.clone(), target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfn subset_sum_i_naive(nums: &[i32], target: i32) -> Vec<Vec<i32>> {\n    let state = Vec::new(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    let total = 0; // \u5b50\u96c6\u548c\n    let mut res = Vec::new(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, &mut res);\n    res\n}\n
    subset_sum_i_naive.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (total == target) {\n        for (int i = 0; i < stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choicesSize; i++) {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state[stateSize++] = choices[i];\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        stateSize--;\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // \u521d\u59cb\u5316\u89e3\u7684\u6570\u91cf\u4e3a0\n    backtrack(target, 0, nums, numsSize);\n}\n
    subset_sum_i_naive.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfun backtrack(\n    state: MutableList<Int>,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList<List<Int>?>\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (total == target) {\n        res.add(ArrayList(state))\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (i in choices.indices) {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if (total + choices[i] > target) {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.add(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res)\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfun subsetSumINaive(nums: IntArray, target: Int): List<List<Int>?> {\n    val state: MutableList<Int> = ArrayList() // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    val total = 0 // \u5b50\u96c6\u548c\n    val res: MutableList<List<Int>?> = ArrayList() // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res)\n    return res\n}\n
    subset_sum_i_naive.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subset_sum_i_naive}\n
    subset_sum_i_naive.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subsetSumINaive}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\u7136\u800c\u5b50\u96c6\u4e0d\u533a\u5206\u9009\u62e9\u987a\u5e8f\u3002\u5982\u56fe 13-10 \u6240\u793a\uff0c\u5148\u9009 \\(4\\) \u540e\u9009 \\(5\\) \u4e0e\u5148\u9009 \\(5\\) \u540e\u9009 \\(4\\) \u662f\u4e0d\u540c\u7684\u5206\u652f\uff0c\u4f46\u5bf9\u5e94\u540c\u4e00\u4e2a\u5b50\u96c6\u3002

    \u56fe 13-10 \u00a0 \u5b50\u96c6\u641c\u7d22\u4e0e\u8d8a\u754c\u526a\u679d

    \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\u6709\u4e24\u65b9\u9762\u539f\u56e0\u3002

    • \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\u975e\u5e38\u8017\u65f6\uff0c\u9700\u8981\u5148\u6392\u5e8f\u6570\u7ec4\uff0c\u518d\u6bd4\u8f83\u6570\u7ec4\u4e2d\u6bcf\u4e2a\u5143\u7d20\u7684\u5f02\u540c\u3002
    "},{"location":"chapter_backtracking/subset_sum_problem/#2","title":"2. \u00a0 \u91cd\u590d\u5b50\u96c6\u526a\u679d","text":"

    \u6211\u4eec\u8003\u8651\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u901a\u8fc7\u526a\u679d\u8fdb\u884c\u53bb\u91cd\u3002\u89c2\u5bdf\u56fe 13-11 \uff0c\u91cd\u590d\u5b50\u96c6\u662f\u5728\u4ee5\u4e0d\u540c\u987a\u5e8f\u9009\u62e9\u6570\u7ec4\u5143\u7d20\u65f6\u4ea7\u751f\u7684\uff0c\u4f8b\u5982\u4ee5\u4e0b\u60c5\u51b5\u3002

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

    \u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6bcf\u4e00\u5c42\u7684\u9009\u62e9\u90fd\u662f\u4ece\u5de6\u5230\u53f3\u88ab\u9010\u4e2a\u5c1d\u8bd5\u7684\uff0c\u56e0\u6b64\u8d8a\u9760\u53f3\u7684\u5206\u652f\u88ab\u526a\u6389\u7684\u8d8a\u591a\u3002

    1. \u524d\u4e24\u8f6e\u9009\u62e9 \\(3\\) \u548c \\(5\\) \uff0c\u751f\u6210\u5b50\u96c6 \\([3, 5, \\dots]\\) \u3002
    2. \u524d\u4e24\u8f6e\u9009\u62e9 \\(4\\) \u548c \\(5\\) \uff0c\u751f\u6210\u5b50\u96c6 \\([4, 5, \\dots]\\) \u3002
    3. \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, \\dots]\\) \u548c \\([5, 4, \\dots]\\) \u4e0e\u7b2c 1. \u6b65\u548c\u7b2c 2. \u6b65\u4e2d\u63cf\u8ff0\u7684\u5b50\u96c6\u5b8c\u5168\u91cd\u590d\u3002

    \u56fe 13-11 \u00a0 \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, \\dots, x_n]\\) \uff0c\u8bbe\u641c\u7d22\u8fc7\u7a0b\u4e2d\u7684\u9009\u62e9\u5e8f\u5217\u4e3a \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\) \uff0c\u5219\u8be5\u9009\u62e9\u5e8f\u5217\u9700\u8981\u6ee1\u8db3 \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) \uff0c\u4e0d\u6ee1\u8db3\u8be5\u6761\u4ef6\u7684\u9009\u62e9\u5e8f\u5217\u90fd\u4f1a\u9020\u6210\u91cd\u590d\uff0c\u5e94\u5f53\u526a\u679d\u3002

    "},{"location":"chapter_backtracking/subset_sum_problem/#3","title":"3. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u4e3a\u5b9e\u73b0\u8be5\u526a\u679d\uff0c\u6211\u4eec\u521d\u59cb\u5316\u53d8\u91cf start \uff0c\u7528\u4e8e\u6307\u793a\u904d\u5386\u8d77\u59cb\u70b9\u3002\u5f53\u505a\u51fa\u9009\u62e9 \\(x_{i}\\) \u540e\uff0c\u8bbe\u5b9a\u4e0b\u4e00\u8f6e\u4ece\u7d22\u5f15 \\(i\\) \u5f00\u59cb\u904d\u5386\u3002\u8fd9\u6837\u505a\u5c31\u53ef\u4ee5\u8ba9\u9009\u62e9\u5e8f\u5217\u6ee1\u8db3 \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) \uff0c\u4ece\u800c\u4fdd\u8bc1\u5b50\u96c6\u552f\u4e00\u3002

    \u9664\u6b64\u4e4b\u5916\uff0c\u6211\u4eec\u8fd8\u5bf9\u4ee3\u7801\u8fdb\u884c\u4e86\u4ee5\u4e0b\u4e24\u9879\u4f18\u5316\u3002

    • \u5728\u5f00\u542f\u641c\u7d22\u524d\uff0c\u5148\u5c06\u6570\u7ec4 nums \u6392\u5e8f\u3002\u5728\u904d\u5386\u6240\u6709\u9009\u62e9\u65f6\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\u4e00\u5b9a\u8d85\u8fc7 target \u3002
    • \u7701\u53bb\u5143\u7d20\u548c\u53d8\u91cf total \uff0c\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\u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig subset_sum_i.py
    def backtrack(\n    state: 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\n    if target == 0:\n        res.append(list(state))\n        return\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    for 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\n        if target - choices[i] < 0:\n            break\n        # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.append(choices[i])\n        # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res)\n        # \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -> list[list[int]]:\n    \"\"\"\u6c42\u89e3\u5b50\u96c6\u548c I\"\"\"\n    state = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort()  # \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    start = 0  # \u904d\u5386\u8d77\u59cb\u70b9\n    res = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res)\n    return res\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\n    if (target == 0) {\n        res.push_back(state);\n        return;\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    for (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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push_back(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop_back();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nvector<vector<int>> subsetSumI(vector<int> &nums, int target) {\n    vector<int> state;              // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    sort(nums.begin(), nums.end()); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0;                  // \u904d\u5386\u8d77\u59cb\u70b9\n    vector<vector<int>> res;        // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    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\n    if (target == 0) {\n        res.add(new ArrayList<>(state));\n        return;\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    for (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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.remove(state.size() - 1);\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<Integer>> subsetSumI(int[] nums, int target) {\n    List<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Arrays.sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    List<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\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\n    if (target == 0) {\n        res.Add(new List<int>(state));\n        return;\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    for (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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.Add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        Backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<int>> SubsetSumI(int[] nums, int target) {\n    List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Array.Sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\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\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\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    for 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\n        if target-(*choices)[i] < 0 {\n            break\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\n        backtrackSubsetSumI(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\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    sort.Ints(nums)         // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    start := 0              // \u904d\u5386\u8d77\u59cb\u70b9\n    res := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrackSubsetSumI(start, target, &state, &nums, &res)\n    return 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\n    if target == 0 {\n        res.append(state)\n        return\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    for i in choices.indices.dropFirst(start) {\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\n        if target - choices[i] < 0 {\n            break\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.append(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.removeLast()\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunc subsetSumI(nums: [Int], target: Int) -> [[Int]] {\n    var state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    let nums = nums.sorted() // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    let start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\n    var res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state: &state, target: target, choices: nums, start: start, res: &res)\n    return res\n}\n
    subset_sum_i.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunction backtrack(state, target, choices, start, res) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target === 0) {\n        res.push([...state]);\n        return;\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    for (let 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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunction subsetSumI(nums, target) {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort((a, b) => a - b); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    const start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    subset_sum_i.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target === 0) {\n        res.push([...state]);\n        return;\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    for (let 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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort((a, b) => a - b); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    const start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    subset_sum_i.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(\n  List<int> state,\n  int target,\n  List<int> choices,\n  int start,\n  List<List<int>> res,\n) {\n  // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\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  for (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\n    if (target - choices[i] < 0) {\n      break;\n    }\n    // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n    state.add(choices[i]);\n    // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n    backtrack(state, target - choices[i], choices, i, res);\n    // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n    state.removeLast();\n  }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<int>> subsetSumI(List<int> nums, int target) {\n  List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n  nums.sort(); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n  int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n  List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n
    subset_sum_i.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfn backtrack(\n    mut state: Vec<i32>,\n    target: i32,\n    choices: &[i32],\n    start: usize,\n    res: &mut Vec<Vec<i32>>,\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if target == 0 {\n        res.push(state);\n        return;\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    for i in start..choices.len() {\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\n        if target - choices[i] < 0 {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state.clone(), target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfn subset_sum_i(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {\n    let state = Vec::new(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort(); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    let start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    let mut res = Vec::new(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, &mut res);\n    res\n}\n
    subset_sum_i.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target == 0) {\n        for (int i = 0; i < stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\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    for (int i = start; i < choicesSize; 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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        stateSize--;\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0;                           // \u904d\u5386\u8d77\u59cb\u70b9\n    backtrack(target, nums, numsSize, start);\n}\n
    subset_sum_i.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfun backtrack(\n    state: MutableList<Int>,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList<List<Int>?>\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target == 0) {\n        res.add(ArrayList(state))\n        return\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    for (i in start..<choices.size) {\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\n        if (target - choices[i] < 0) {\n            break\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.add(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res)\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfun subsetSumI(nums: IntArray, target: Int): List<List<Int>?> {\n    val state: MutableList<Int> = ArrayList() // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Arrays.sort(nums) // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    val start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\n    val res: MutableList<List<Int>?> = ArrayList() // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res)\n    return res\n}\n
    subset_sum_i.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subset_sum_i}\n
    subset_sum_i.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subsetSumI}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

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

    \u56fe 13-12 \u00a0 \u5b50\u96c6\u548c I \u56de\u6eaf\u8fc7\u7a0b

    "},{"location":"chapter_backtracking/subset_sum_problem/#1332","title":"13.3.2 \u00a0 \u8003\u8651\u91cd\u590d\u5143\u7d20\u7684\u60c5\u51b5","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\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\u5728\u56fe 13-13 \u4e2d\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

    \u56fe 13-13 \u00a0 \u76f8\u7b49\u5143\u7d20\u5bfc\u81f4\u7684\u91cd\u590d\u5b50\u96c6

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

    \u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u9700\u8981\u9650\u5236\u76f8\u7b49\u5143\u7d20\u5728\u6bcf\u4e00\u8f6e\u4e2d\u53ea\u80fd\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\u8fd9\u610f\u5473\u7740\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\u6bcf\u4e2a\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\u65e2\u80fd\u53bb\u9664\u91cd\u590d\u5b50\u96c6\uff0c\u4e5f\u80fd\u907f\u514d\u91cd\u590d\u9009\u62e9\u5143\u7d20\u3002

    "},{"location":"chapter_backtracking/subset_sum_problem/#2_1","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig subset_sum_ii.py
    def backtrack(\n    state: 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\n    if target == 0:\n        res.append(list(state))\n        return\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\n    for 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\n        if target - choices[i] < 0:\n            break\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\n        if i > start and choices[i] == choices[i - 1]:\n            continue\n        # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.append(choices[i])\n        # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -> list[list[int]]:\n    \"\"\"\u6c42\u89e3\u5b50\u96c6\u548c II\"\"\"\n    state = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort()  # \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    start = 0  # \u904d\u5386\u8d77\u59cb\u70b9\n    res = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res)\n    return res\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\n    if (target == 0) {\n        res.push_back(state);\n        return;\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\n    for (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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push_back(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.pop_back();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nvector<vector<int>> subsetSumII(vector<int> &nums, int target) {\n    vector<int> state;              // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    sort(nums.begin(), nums.end()); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0;                  // \u904d\u5386\u8d77\u59cb\u70b9\n    vector<vector<int>> res;        // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    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\n    if (target == 0) {\n        res.add(new ArrayList<>(state));\n        return;\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\n    for (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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.remove(state.size() - 1);\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<Integer>> subsetSumII(int[] nums, int target) {\n    List<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Arrays.sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    List<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\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\n    if (target == 0) {\n        res.Add(new List<int>(state));\n        return;\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\n    for (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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.Add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        Backtrack(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\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<int>> SubsetSumII(int[] nums, int target) {\n    List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Array.Sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\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\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\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\n    for 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\n        if target-(*choices)[i] < 0 {\n            break\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\n        if i > start && (*choices)[i] == (*choices)[i-1] {\n            continue\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\n        backtrackSubsetSumII(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\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    sort.Ints(nums)         // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    start := 0              // \u904d\u5386\u8d77\u59cb\u70b9\n    res := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrackSubsetSumII(start, target, &state, &nums, &res)\n    return 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\n    if target == 0 {\n        res.append(state)\n        return\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\n    for i in choices.indices.dropFirst(start) {\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\n        if target - choices[i] < 0 {\n            break\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\n        if i > start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.append(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.removeLast()\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunc subsetSumII(nums: [Int], target: Int) -> [[Int]] {\n    var state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    let nums = nums.sorted() // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    let start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\n    var res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state: &state, target: target, choices: nums, start: start, res: &res)\n    return res\n}\n
    subset_sum_ii.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfunction backtrack(state, target, choices, start, res) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target === 0) {\n        res.push([...state]);\n        return;\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\n    for (let 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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunction subsetSumII(nums, target) {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort((a, b) => a - b); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    const start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    subset_sum_ii.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target === 0) {\n        res.push([...state]);\n        return;\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\n    for (let 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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort((a, b) => a - b); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    const start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    subset_sum_ii.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(\n  List<int> state,\n  int target,\n  List<int> choices,\n  int start,\n  List<List<int>> res,\n) {\n  // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\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\n  for (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\n    if (target - choices[i] < 0) {\n      break;\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\n    if (i > start && choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n    state.add(choices[i]);\n    // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n    backtrack(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\n    state.removeLast();\n  }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<int>> subsetSumII(List<int> nums, int target) {\n  List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n  nums.sort(); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n  int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n  List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n
    subset_sum_ii.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfn backtrack(\n    mut state: Vec<i32>,\n    target: i32,\n    choices: &[i32],\n    start: usize,\n    res: &mut Vec<Vec<i32>>,\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if target == 0 {\n        res.push(state);\n        return;\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\n    for i in start..choices.len() {\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\n        if target - choices[i] < 0 {\n            break;\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\n        if i > start && choices[i] == choices[i - 1] {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state.clone(), target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfn subset_sum_ii(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {\n    let state = Vec::new(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort(); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    let start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    let mut res = Vec::new(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, &mut res);\n    res\n}\n
    subset_sum_ii.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target == 0) {\n        for (int i = 0; i < stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\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\n    for (int i = start; i < choicesSize; i++) {\n        // \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\n        if (target - choices[i] < 0) {\n            continue;\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        stateSize--;\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // \u5f00\u59cb\u56de\u6eaf\n    backtrack(target, nums, numsSize, 0);\n}\n
    subset_sum_ii.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfun backtrack(\n    state: MutableList<Int>,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList<List<Int>?>\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target == 0) {\n        res.add(ArrayList(state))\n        return\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\n    for (i in start..<choices.size) {\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\n        if (target - choices[i] < 0) {\n            break\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.add(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfun subsetSumII(nums: IntArray, target: Int): List<List<Int>?> {\n    val state: MutableList<Int> = ArrayList() // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Arrays.sort(nums) // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    val start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\n    val res: MutableList<List<Int>?> = ArrayList() // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res)\n    return res\n}\n
    subset_sum_ii.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subset_sum_ii}\n
    subset_sum_ii.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subsetSumII}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 13-14 \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\u8bf7\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

    \u56fe 13-14 \u00a0 \u5b50\u96c6\u548c II \u56de\u6eaf\u8fc7\u7a0b

    "},{"location":"chapter_backtracking/summary/","title":"13.5 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_backtracking/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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\u6548\u7387\u66f4\u9ad8\u6216\u6548\u679c\u66f4\u597d\u7684\u89e3\u6cd5\u3002
    • \u5168\u6392\u5217\u95ee\u9898\u65e8\u5728\u641c\u7d22\u7ed9\u5b9a\u96c6\u5408\u5143\u7d20\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\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\u59cb\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\u95ee\u9898\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\u6b21\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\u6b21\u5bf9\u89d2\u7ebf\u4e0a\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_backtracking/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\u600e\u4e48\u7406\u89e3\u56de\u6eaf\u548c\u9012\u5f52\u7684\u5173\u7cfb\uff1f

    \u603b\u7684\u6765\u770b\uff0c\u56de\u6eaf\u662f\u4e00\u79cd\u201c\u7b97\u6cd5\u7b56\u7565\u201d\uff0c\u800c\u9012\u5f52\u66f4\u50cf\u662f\u4e00\u4e2a\u201c\u5de5\u5177\u201d\u3002

    • \u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u5b9e\u73b0\u3002\u7136\u800c\uff0c\u56de\u6eaf\u662f\u9012\u5f52\u7684\u5e94\u7528\u573a\u666f\u4e4b\u4e00\uff0c\u662f\u9012\u5f52\u5728\u641c\u7d22\u95ee\u9898\u4e2d\u7684\u5e94\u7528\u3002
    • \u9012\u5f52\u7684\u7ed3\u6784\u4f53\u73b0\u4e86\u201c\u5b50\u95ee\u9898\u5206\u89e3\u201d\u7684\u89e3\u9898\u8303\u5f0f\uff0c\u5e38\u7528\u4e8e\u89e3\u51b3\u5206\u6cbb\u3001\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\uff08\u8bb0\u5fc6\u5316\u9012\u5f52\uff09\u7b49\u95ee\u9898\u3002
    "},{"location":"chapter_computational_complexity/","title":"\u7b2c 2 \u7ae0 \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    Abstract

    \u590d\u6742\u5ea6\u5206\u6790\u72b9\u5982\u6d69\u701a\u7684\u7b97\u6cd5\u5b87\u5b99\u4e2d\u7684\u65f6\u7a7a\u5411\u5bfc\u3002

    \u5b83\u5e26\u9886\u6211\u4eec\u5728\u65f6\u95f4\u4e0e\u7a7a\u95f4\u8fd9\u4e24\u4e2a\u7ef4\u5ea6\u4e0a\u6df1\u5165\u63a2\u7d22\uff0c\u5bfb\u627e\u66f4\u4f18\u96c5\u7684\u89e3\u51b3\u65b9\u6848\u3002

    "},{"location":"chapter_computational_complexity/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 2.1 \u00a0 \u7b97\u6cd5\u6548\u7387\u8bc4\u4f30
    • 2.2 \u00a0 \u8fed\u4ee3\u4e0e\u9012\u5f52
    • 2.3 \u00a0 \u65f6\u95f4\u590d\u6742\u5ea6
    • 2.4 \u00a0 \u7a7a\u95f4\u590d\u6742\u5ea6
    • 2.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/","title":"2.2 \u00a0 \u8fed\u4ee3\u4e0e\u9012\u5f52","text":"

    \u5728\u7b97\u6cd5\u4e2d\uff0c\u91cd\u590d\u6267\u884c\u67d0\u4e2a\u4efb\u52a1\u662f\u5f88\u5e38\u89c1\u7684\uff0c\u5b83\u4e0e\u590d\u6742\u5ea6\u5206\u6790\u606f\u606f\u76f8\u5173\u3002\u56e0\u6b64\uff0c\u5728\u4ecb\u7ecd\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e4b\u524d\uff0c\u6211\u4eec\u5148\u6765\u4e86\u89e3\u5982\u4f55\u5728\u7a0b\u5e8f\u4e2d\u5b9e\u73b0\u91cd\u590d\u6267\u884c\u4efb\u52a1\uff0c\u5373\u4e24\u79cd\u57fa\u672c\u7684\u7a0b\u5e8f\u63a7\u5236\u7ed3\u6784\uff1a\u8fed\u4ee3\u3001\u9012\u5f52\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#221","title":"2.2.1 \u00a0 \u8fed\u4ee3","text":"

    \u300c\u8fed\u4ee3 iteration\u300d\u662f\u4e00\u79cd\u91cd\u590d\u6267\u884c\u67d0\u4e2a\u4efb\u52a1\u7684\u63a7\u5236\u7ed3\u6784\u3002\u5728\u8fed\u4ee3\u4e2d\uff0c\u7a0b\u5e8f\u4f1a\u5728\u6ee1\u8db3\u4e00\u5b9a\u7684\u6761\u4ef6\u4e0b\u91cd\u590d\u6267\u884c\u67d0\u6bb5\u4ee3\u7801\uff0c\u76f4\u5230\u8fd9\u4e2a\u6761\u4ef6\u4e0d\u518d\u6ee1\u8db3\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for","title":"1. \u00a0 for \u5faa\u73af","text":"

    for \u5faa\u73af\u662f\u6700\u5e38\u89c1\u7684\u8fed\u4ee3\u5f62\u5f0f\u4e4b\u4e00\uff0c\u9002\u5408\u5728\u9884\u5148\u77e5\u9053\u8fed\u4ee3\u6b21\u6570\u65f6\u4f7f\u7528\u3002

    \u4ee5\u4e0b\u51fd\u6570\u57fa\u4e8e for \u5faa\u73af\u5b9e\u73b0\u4e86\u6c42\u548c \\(1 + 2 + \\dots + n\\) \uff0c\u6c42\u548c\u7ed3\u679c\u4f7f\u7528\u53d8\u91cf res \u8bb0\u5f55\u3002\u9700\u8981\u6ce8\u610f\u7684\u662f\uff0cPython \u4e2d range(a, b) \u5bf9\u5e94\u7684\u533a\u95f4\u662f\u201c\u5de6\u95ed\u53f3\u5f00\u201d\u7684\uff0c\u5bf9\u5e94\u7684\u904d\u5386\u8303\u56f4\u4e3a \\(a, a + 1, \\dots, b-1\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def for_loop(n: int) -> int:\n    \"\"\"for \u5faa\u73af\"\"\"\n    res = 0\n    # \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n
    iteration.cpp
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.java
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.cs
    /* for \u5faa\u73af */\nint ForLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.go
    /* for \u5faa\u73af */\nfunc forLoop(n int) int {\n    res := 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i := 1; i <= n; i++ {\n        res += i\n    }\n    return res\n}\n
    iteration.swift
    /* for \u5faa\u73af */\nfunc forLoop(n: Int) -> Int {\n    var res = 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n
    iteration.js
    /* for \u5faa\u73af */\nfunction forLoop(n) {\n    let res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.ts
    /* for \u5faa\u73af */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.dart
    /* for \u5faa\u73af */\nint forLoop(int n) {\n  int res = 0;\n  // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n  for (int i = 1; i <= n; i++) {\n    res += i;\n  }\n  return res;\n}\n
    iteration.rs
    /* for \u5faa\u73af */\nfn for_loop(n: i32) -> i32 {\n    let mut res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n
    iteration.c
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.kt
    /* for \u5faa\u73af */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{for_loop}\n
    iteration.zig
    // for \u5faa\u73af\nfn forLoop(n: usize) i32 {\n    var res: i32 = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (1..n+1) |i| {\n        res = res + @as(i32, @intCast(i));\n    }\n    return res;\n} \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-1 \u662f\u8be5\u6c42\u548c\u51fd\u6570\u7684\u6d41\u7a0b\u6846\u56fe\u3002

    \u56fe 2-1 \u00a0 \u6c42\u548c\u51fd\u6570\u7684\u6d41\u7a0b\u6846\u56fe

    \u6b64\u6c42\u548c\u51fd\u6570\u7684\u64cd\u4f5c\u6570\u91cf\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u6210\u6b63\u6bd4\uff0c\u6216\u8005\u8bf4\u6210\u201c\u7ebf\u6027\u5173\u7cfb\u201d\u3002\u5b9e\u9645\u4e0a\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u63cf\u8ff0\u7684\u5c31\u662f\u8fd9\u4e2a\u201c\u7ebf\u6027\u5173\u7cfb\u201d\u3002\u76f8\u5173\u5185\u5bb9\u5c06\u4f1a\u5728\u4e0b\u4e00\u8282\u4e2d\u8be6\u7ec6\u4ecb\u7ecd\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while","title":"2. \u00a0 while \u5faa\u73af","text":"

    \u4e0e for \u5faa\u73af\u7c7b\u4f3c\uff0cwhile \u5faa\u73af\u4e5f\u662f\u4e00\u79cd\u5b9e\u73b0\u8fed\u4ee3\u7684\u65b9\u6cd5\u3002\u5728 while \u5faa\u73af\u4e2d\uff0c\u7a0b\u5e8f\u6bcf\u8f6e\u90fd\u4f1a\u5148\u68c0\u67e5\u6761\u4ef6\uff0c\u5982\u679c\u6761\u4ef6\u4e3a\u771f\uff0c\u5219\u7ee7\u7eed\u6267\u884c\uff0c\u5426\u5219\u5c31\u7ed3\u675f\u5faa\u73af\u3002

    \u4e0b\u9762\u6211\u4eec\u7528 while \u5faa\u73af\u6765\u5b9e\u73b0\u6c42\u548c \\(1 + 2 + \\dots + n\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def while_loop(n: int) -> int:\n    \"\"\"while \u5faa\u73af\"\"\"\n    res = 0\n    i = 1  # \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    # \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n:\n        res += i\n        i += 1  # \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    return res\n
    iteration.cpp
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.java
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.cs
    /* while \u5faa\u73af */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i += 1; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.go
    /* while \u5faa\u73af */\nfunc whileLoop(n int) int {\n    res := 0\n    // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    i := 1\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n    }\n    return res\n}\n
    iteration.swift
    /* while \u5faa\u73af */\nfunc whileLoop(n: Int) -> Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n {\n        res += i\n        i += 1 // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res\n}\n
    iteration.js
    /* while \u5faa\u73af */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.ts
    /* while \u5faa\u73af */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.dart
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n  // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n  while (i <= n) {\n    res += i;\n    i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n  }\n  return res;\n}\n
    iteration.rs
    /* while \u5faa\u73af */\nfn while_loop(n: i32) -> i32 {\n    let mut res = 0;\n    let mut i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n {\n        res += i;\n        i += 1; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    res\n}\n
    iteration.c
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.kt
    /* while \u5faa\u73af */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i\n        i++ // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{while_loop}\n
    iteration.zig
    // while \u5faa\u73af\nfn whileLoop(n: i32) i32 {\n    var res: i32 = 0;\n    var i: i32 = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += @intCast(i);\n        i += 1;\n    }\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    while \u5faa\u73af\u6bd4 for \u5faa\u73af\u7684\u81ea\u7531\u5ea6\u66f4\u9ad8\u3002\u5728 while \u5faa\u73af\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u81ea\u7531\u5730\u8bbe\u8ba1\u6761\u4ef6\u53d8\u91cf\u7684\u521d\u59cb\u5316\u548c\u66f4\u65b0\u6b65\u9aa4\u3002

    \u4f8b\u5982\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u6761\u4ef6\u53d8\u91cf \\(i\\) \u6bcf\u8f6e\u8fdb\u884c\u4e24\u6b21\u66f4\u65b0\uff0c\u8fd9\u79cd\u60c5\u51b5\u5c31\u4e0d\u592a\u65b9\u4fbf\u7528 for \u5faa\u73af\u5b9e\u73b0\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def while_loop_ii(n: int) -> int:\n    \"\"\"while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09\"\"\"\n    res = 0\n    i = 1  # \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    # \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n:\n        res += i\n        # \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1\n        i *= 2\n    return res\n
    iteration.cpp
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.java
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.cs
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n
    iteration.go
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunc whileLoopII(n int) int {\n    res := 0\n    // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    i := 1\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    for i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n        i *= 2\n    }\n    return res\n}\n
    iteration.swift
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunc whileLoopII(n: Int) -> Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1\n        i *= 2\n    }\n    return res\n}\n
    iteration.js
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.ts
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.dart
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n  // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n  while (i <= n) {\n    res += i;\n    // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n
    iteration.rs
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfn while_loop_ii(n: i32) -> i32 {\n    let mut res = 0;\n    let mut i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n
    iteration.c
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.kt
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n        i *= 2\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{while_loop_ii}\n
    iteration.zig
    //  while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09\nfn whileLoopII(n: i32) i32 {\n    var res: i32 = 0;\n    var i: i32 = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += @intCast(i);\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1;\n        i *= 2;\n    }\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u603b\u7684\u6765\u8bf4\uff0cfor \u5faa\u73af\u7684\u4ee3\u7801\u66f4\u52a0\u7d27\u51d1\uff0cwhile \u5faa\u73af\u66f4\u52a0\u7075\u6d3b\uff0c\u4e24\u8005\u90fd\u53ef\u4ee5\u5b9e\u73b0\u8fed\u4ee3\u7ed3\u6784\u3002\u9009\u62e9\u4f7f\u7528\u54ea\u4e00\u4e2a\u5e94\u8be5\u6839\u636e\u7279\u5b9a\u95ee\u9898\u7684\u9700\u6c42\u6765\u51b3\u5b9a\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#3","title":"3. \u00a0 \u5d4c\u5957\u5faa\u73af","text":"

    \u6211\u4eec\u53ef\u4ee5\u5728\u4e00\u4e2a\u5faa\u73af\u7ed3\u6784\u5185\u5d4c\u5957\u53e6\u4e00\u4e2a\u5faa\u73af\u7ed3\u6784\uff0c\u4e0b\u9762\u4ee5 for \u5faa\u73af\u4e3a\u4f8b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def nested_for_loop(n: int) -> str:\n    \"\"\"\u53cc\u5c42 for \u5faa\u73af\"\"\"\n    res = \"\"\n    # \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n
    iteration.cpp
    /* \u53cc\u5c42 for \u5faa\u73af */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; ++i) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; ++j) {\n            res << \"(\" << i << \", \" << j << \"), \";\n        }\n    }\n    return res.str();\n}\n
    iteration.java
    /* \u53cc\u5c42 for \u5faa\u73af */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n
    iteration.cs
    /* \u53cc\u5c42 for \u5faa\u73af */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n
    iteration.go
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i := 1; i <= n; i++ {\n        for j := 1; j <= n; j++ {\n            // \u5faa\u73af j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n
    iteration.swift
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunc nestedForLoop(n: Int) -> String {\n    var res = \"\"\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n
    iteration.js
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunction nestedForLoop(n) {\n    let res = '';\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (let j = 1; j <= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n
    iteration.ts
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (let j = 1; j <= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n
    iteration.dart
    /* \u53cc\u5c42 for \u5faa\u73af */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // \u5faa\u73af i = 1, 2, ..., n-1, n\n  for (int i = 1; i <= n; i++) {\n    // \u5faa\u73af j = 1, 2, ..., n-1, n\n    for (int j = 1; j <= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n
    iteration.rs
    /* \u53cc\u5c42 for \u5faa\u73af */\nfn nested_for_loop(n: i32) -> String {\n    let mut res = vec![];\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n
    iteration.c
    /* \u53cc\u5c42 for \u5faa\u73af */\nchar *nestedForLoop(int n) {\n    // n * n \u4e3a\u5bf9\u5e94\u70b9\u6570\u91cf\uff0c\"(i, j), \" \u5bf9\u5e94\u5b57\u7b26\u4e32\u957f\u6700\u5927\u4e3a 6+10*2\uff0c\u52a0\u4e0a\u6700\u540e\u4e00\u4e2a\u7a7a\u5b57\u7b26 \\0 \u7684\u989d\u5916\u7a7a\u95f4\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n
    iteration.kt
    /* \u53cc\u5c42 for \u5faa\u73af */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n
    iteration.rb
    [class]{}-[func]{nested_for_loop}\n
    iteration.zig
    // \u53cc\u5c42 for \u5faa\u73af\nfn nestedForLoop(allocator: Allocator, n: usize) ![]const u8 {\n    var res = std.ArrayList(u8).init(allocator);\n    defer res.deinit();\n    var buffer: [20]u8 = undefined;\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (1..n+1) |i| {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (1..n+1) |j| {\n            var _str = try std.fmt.bufPrint(&buffer, \"({d}, {d}), \", .{i, j});\n            try res.appendSlice(_str);\n        }\n    }\n    return res.toOwnedSlice();\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-2 \u662f\u8be5\u5d4c\u5957\u5faa\u73af\u7684\u6d41\u7a0b\u6846\u56fe\u3002

    \u56fe 2-2 \u00a0 \u5d4c\u5957\u5faa\u73af\u7684\u6d41\u7a0b\u6846\u56fe

    \u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u51fd\u6570\u7684\u64cd\u4f5c\u6570\u91cf\u4e0e \\(n^2\\) \u6210\u6b63\u6bd4\uff0c\u6216\u8005\u8bf4\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u548c\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u6210\u201c\u5e73\u65b9\u5173\u7cfb\u201d\u3002

    \u6211\u4eec\u53ef\u4ee5\u7ee7\u7eed\u6dfb\u52a0\u5d4c\u5957\u5faa\u73af\uff0c\u6bcf\u4e00\u6b21\u5d4c\u5957\u90fd\u662f\u4e00\u6b21\u201c\u5347\u7ef4\u201d\uff0c\u5c06\u4f1a\u4f7f\u65f6\u95f4\u590d\u6742\u5ea6\u63d0\u9ad8\u81f3\u201c\u7acb\u65b9\u5173\u7cfb\u201d\u201c\u56db\u6b21\u65b9\u5173\u7cfb\u201d\uff0c\u4ee5\u6b64\u7c7b\u63a8\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#222","title":"2.2.2 \u00a0 \u9012\u5f52","text":"

    \u300c\u9012\u5f52 recursion\u300d\u662f\u4e00\u79cd\u7b97\u6cd5\u7b56\u7565\uff0c\u901a\u8fc7\u51fd\u6570\u8c03\u7528\u81ea\u8eab\u6765\u89e3\u51b3\u95ee\u9898\u3002\u5b83\u4e3b\u8981\u5305\u542b\u4e24\u4e2a\u9636\u6bb5\u3002

    1. \u9012\uff1a\u7a0b\u5e8f\u4e0d\u65ad\u6df1\u5165\u5730\u8c03\u7528\u81ea\u8eab\uff0c\u901a\u5e38\u4f20\u5165\u66f4\u5c0f\u6216\u66f4\u7b80\u5316\u7684\u53c2\u6570\uff0c\u76f4\u5230\u8fbe\u5230\u201c\u7ec8\u6b62\u6761\u4ef6\u201d\u3002
    2. \u5f52\uff1a\u89e6\u53d1\u201c\u7ec8\u6b62\u6761\u4ef6\u201d\u540e\uff0c\u7a0b\u5e8f\u4ece\u6700\u6df1\u5c42\u7684\u9012\u5f52\u51fd\u6570\u5f00\u59cb\u9010\u5c42\u8fd4\u56de\uff0c\u6c47\u805a\u6bcf\u4e00\u5c42\u7684\u7ed3\u679c\u3002

    \u800c\u4ece\u5b9e\u73b0\u7684\u89d2\u5ea6\u770b\uff0c\u9012\u5f52\u4ee3\u7801\u4e3b\u8981\u5305\u542b\u4e09\u4e2a\u8981\u7d20\u3002

    1. \u7ec8\u6b62\u6761\u4ef6\uff1a\u7528\u4e8e\u51b3\u5b9a\u4ec0\u4e48\u65f6\u5019\u7531\u201c\u9012\u201d\u8f6c\u201c\u5f52\u201d\u3002
    2. \u9012\u5f52\u8c03\u7528\uff1a\u5bf9\u5e94\u201c\u9012\u201d\uff0c\u51fd\u6570\u8c03\u7528\u81ea\u8eab\uff0c\u901a\u5e38\u8f93\u5165\u66f4\u5c0f\u6216\u66f4\u7b80\u5316\u7684\u53c2\u6570\u3002
    3. \u8fd4\u56de\u7ed3\u679c\uff1a\u5bf9\u5e94\u201c\u5f52\u201d\uff0c\u5c06\u5f53\u524d\u9012\u5f52\u5c42\u7ea7\u7684\u7ed3\u679c\u8fd4\u56de\u81f3\u4e0a\u4e00\u5c42\u3002

    \u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff0c\u6211\u4eec\u53ea\u9700\u8c03\u7528\u51fd\u6570 recur(n) \uff0c\u5c31\u53ef\u4ee5\u5b8c\u6210 \\(1 + 2 + \\dots + n\\) \u7684\u8ba1\u7b97\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def recur(n: int) -> int:\n    \"\"\"\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if n == 1:\n        return 1\n    # \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    res = recur(n - 1)\n    # \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n
    recursion.cpp
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.java
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.cs
    /* \u9012\u5f52 */\nint Recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = Recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.go
    /* \u9012\u5f52 */\nfunc recur(n int) int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    res := recur(n - 1)\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.swift
    /* \u9012\u5f52 */\nfunc recur(n: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    let res = recur(n: n - 1)\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.js
    /* \u9012\u5f52 */\nfunction recur(n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 1) return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    const res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.ts
    /* \u9012\u5f52 */\nfunction recur(n: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 1) return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    const res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.dart
    /* \u9012\u5f52 */\nint recur(int n) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (n == 1) return 1;\n  // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n  int res = recur(n - 1);\n  // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n  return n + res;\n}\n
    recursion.rs
    /* \u9012\u5f52 */\nfn recur(n: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1;\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    let res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    n + res\n}\n
    recursion.c
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.kt
    /* \u9012\u5f52 */\nfun recur(n: Int): Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1\n    // \u9012: \u9012\u5f52\u8c03\u7528\n    val res = recur(n - 1)\n    // \u5f52: \u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.rb
    [class]{}-[func]{recur}\n
    recursion.zig
    // \u9012\u5f52\u51fd\u6570\nfn recur(n: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1) {\n        return 1;\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    var res: i32 = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-3 \u5c55\u793a\u4e86\u8be5\u51fd\u6570\u7684\u9012\u5f52\u8fc7\u7a0b\u3002

    \u56fe 2-3 \u00a0 \u6c42\u548c\u51fd\u6570\u7684\u9012\u5f52\u8fc7\u7a0b

    \u867d\u7136\u4ece\u8ba1\u7b97\u89d2\u5ea6\u770b\uff0c\u8fed\u4ee3\u4e0e\u9012\u5f52\u53ef\u4ee5\u5f97\u5230\u76f8\u540c\u7684\u7ed3\u679c\uff0c\u4f46\u5b83\u4eec\u4ee3\u8868\u4e86\u4e24\u79cd\u5b8c\u5168\u4e0d\u540c\u7684\u601d\u8003\u548c\u89e3\u51b3\u95ee\u9898\u7684\u8303\u5f0f\u3002

    • \u8fed\u4ee3\uff1a\u201c\u81ea\u4e0b\u800c\u4e0a\u201d\u5730\u89e3\u51b3\u95ee\u9898\u3002\u4ece\u6700\u57fa\u7840\u7684\u6b65\u9aa4\u5f00\u59cb\uff0c\u7136\u540e\u4e0d\u65ad\u91cd\u590d\u6216\u7d2f\u52a0\u8fd9\u4e9b\u6b65\u9aa4\uff0c\u76f4\u5230\u4efb\u52a1\u5b8c\u6210\u3002
    • \u9012\u5f52\uff1a\u201c\u81ea\u4e0a\u800c\u4e0b\u201d\u5730\u89e3\u51b3\u95ee\u9898\u3002\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\uff0c\u8fd9\u4e9b\u5b50\u95ee\u9898\u548c\u539f\u95ee\u9898\u5177\u6709\u76f8\u540c\u7684\u5f62\u5f0f\u3002\u63a5\u4e0b\u6765\u5c06\u5b50\u95ee\u9898\u7ee7\u7eed\u5206\u89e3\u4e3a\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\uff0c\u76f4\u5230\u57fa\u672c\u60c5\u51b5\u65f6\u505c\u6b62\uff08\u57fa\u672c\u60c5\u51b5\u7684\u89e3\u662f\u5df2\u77e5\u7684\uff09\u3002

    \u4ee5\u4e0a\u8ff0\u6c42\u548c\u51fd\u6570\u4e3a\u4f8b\uff0c\u8bbe\u95ee\u9898 \\(f(n) = 1 + 2 + \\dots + n\\) \u3002

    • \u8fed\u4ee3\uff1a\u5728\u5faa\u73af\u4e2d\u6a21\u62df\u6c42\u548c\u8fc7\u7a0b\uff0c\u4ece \\(1\\) \u904d\u5386\u5230 \\(n\\) \uff0c\u6bcf\u8f6e\u6267\u884c\u6c42\u548c\u64cd\u4f5c\uff0c\u5373\u53ef\u6c42\u5f97 \\(f(n)\\) \u3002
    • \u9012\u5f52\uff1a\u5c06\u95ee\u9898\u5206\u89e3\u4e3a\u5b50\u95ee\u9898 \\(f(n) = n + f(n-1)\\) \uff0c\u4e0d\u65ad\uff08\u9012\u5f52\u5730\uff09\u5206\u89e3\u4e0b\u53bb\uff0c\u76f4\u81f3\u57fa\u672c\u60c5\u51b5 \\(f(1) = 1\\) \u65f6\u7ec8\u6b62\u3002
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#1","title":"1. \u00a0 \u8c03\u7528\u6808","text":"

    \u9012\u5f52\u51fd\u6570\u6bcf\u6b21\u8c03\u7528\u81ea\u8eab\u65f6\uff0c\u7cfb\u7edf\u90fd\u4f1a\u4e3a\u65b0\u5f00\u542f\u7684\u51fd\u6570\u5206\u914d\u5185\u5b58\uff0c\u4ee5\u5b58\u50a8\u5c40\u90e8\u53d8\u91cf\u3001\u8c03\u7528\u5730\u5740\u548c\u5176\u4ed6\u4fe1\u606f\u7b49\u3002\u8fd9\u5c06\u5bfc\u81f4\u4e24\u65b9\u9762\u7684\u7ed3\u679c\u3002

    • \u51fd\u6570\u7684\u4e0a\u4e0b\u6587\u6570\u636e\u90fd\u5b58\u50a8\u5728\u79f0\u4e3a\u201c\u6808\u5e27\u7a7a\u95f4\u201d\u7684\u5185\u5b58\u533a\u57df\u4e2d\uff0c\u76f4\u81f3\u51fd\u6570\u8fd4\u56de\u540e\u624d\u4f1a\u88ab\u91ca\u653e\u3002\u56e0\u6b64\uff0c\u9012\u5f52\u901a\u5e38\u6bd4\u8fed\u4ee3\u66f4\u52a0\u8017\u8d39\u5185\u5b58\u7a7a\u95f4\u3002
    • \u9012\u5f52\u8c03\u7528\u51fd\u6570\u4f1a\u4ea7\u751f\u989d\u5916\u7684\u5f00\u9500\u3002\u56e0\u6b64\u9012\u5f52\u901a\u5e38\u6bd4\u5faa\u73af\u7684\u65f6\u95f4\u6548\u7387\u66f4\u4f4e\u3002

    \u5982\u56fe 2-4 \u6240\u793a\uff0c\u5728\u89e6\u53d1\u7ec8\u6b62\u6761\u4ef6\u524d\uff0c\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684\u9012\u5f52\u51fd\u6570\uff0c\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \u3002

    \u56fe 2-4 \u00a0 \u9012\u5f52\u8c03\u7528\u6df1\u5ea6

    \u5728\u5b9e\u9645\u4e2d\uff0c\u7f16\u7a0b\u8bed\u8a00\u5141\u8bb8\u7684\u9012\u5f52\u6df1\u5ea6\u901a\u5e38\u662f\u6709\u9650\u7684\uff0c\u8fc7\u6df1\u7684\u9012\u5f52\u53ef\u80fd\u5bfc\u81f4\u6808\u6ea2\u51fa\u9519\u8bef\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#2","title":"2. \u00a0 \u5c3e\u9012\u5f52","text":"

    \u6709\u8da3\u7684\u662f\uff0c\u5982\u679c\u51fd\u6570\u5728\u8fd4\u56de\u524d\u7684\u6700\u540e\u4e00\u6b65\u624d\u8fdb\u884c\u9012\u5f52\u8c03\u7528\uff0c\u5219\u8be5\u51fd\u6570\u53ef\u4ee5\u88ab\u7f16\u8bd1\u5668\u6216\u89e3\u91ca\u5668\u4f18\u5316\uff0c\u4f7f\u5176\u5728\u7a7a\u95f4\u6548\u7387\u4e0a\u4e0e\u8fed\u4ee3\u76f8\u5f53\u3002\u8fd9\u79cd\u60c5\u51b5\u88ab\u79f0\u4e3a\u300c\u5c3e\u9012\u5f52 tail recursion\u300d\u3002

    • \u666e\u901a\u9012\u5f52\uff1a\u5f53\u51fd\u6570\u8fd4\u56de\u5230\u4e0a\u4e00\u5c42\u7ea7\u7684\u51fd\u6570\u540e\uff0c\u9700\u8981\u7ee7\u7eed\u6267\u884c\u4ee3\u7801\uff0c\u56e0\u6b64\u7cfb\u7edf\u9700\u8981\u4fdd\u5b58\u4e0a\u4e00\u5c42\u8c03\u7528\u7684\u4e0a\u4e0b\u6587\u3002
    • \u5c3e\u9012\u5f52\uff1a\u9012\u5f52\u8c03\u7528\u662f\u51fd\u6570\u8fd4\u56de\u524d\u7684\u6700\u540e\u4e00\u4e2a\u64cd\u4f5c\uff0c\u8fd9\u610f\u5473\u7740\u51fd\u6570\u8fd4\u56de\u5230\u4e0a\u4e00\u5c42\u7ea7\u540e\uff0c\u65e0\u987b\u7ee7\u7eed\u6267\u884c\u5176\u4ed6\u64cd\u4f5c\uff0c\u56e0\u6b64\u7cfb\u7edf\u65e0\u987b\u4fdd\u5b58\u4e0a\u4e00\u5c42\u51fd\u6570\u7684\u4e0a\u4e0b\u6587\u3002

    \u4ee5\u8ba1\u7b97 \\(1 + 2 + \\dots + n\\) \u4e3a\u4f8b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u7ed3\u679c\u53d8\u91cf res \u8bbe\u4e3a\u51fd\u6570\u53c2\u6570\uff0c\u4ece\u800c\u5b9e\u73b0\u5c3e\u9012\u5f52\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def tail_recur(n, res):\n    \"\"\"\u5c3e\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if n == 0:\n        return res\n    # \u5c3e\u9012\u5f52\u8c03\u7528\n    return tail_recur(n - 1, res + n)\n
    recursion.cpp
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.java
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.cs
    /* \u5c3e\u9012\u5f52 */\nint TailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return TailRecur(n - 1, res + n);\n}\n
    recursion.go
    /* \u5c3e\u9012\u5f52 */\nfunc tailRecur(n int, res int) int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n-1, res+n)\n}\n
    recursion.swift
    /* \u5c3e\u9012\u5f52 */\nfunc tailRecur(n: Int, res: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n: n - 1, res: res + n)\n}\n
    recursion.js
    /* \u5c3e\u9012\u5f52 */\nfunction tailRecur(n, res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 0) return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.ts
    /* \u5c3e\u9012\u5f52 */\nfunction tailRecur(n: number, res: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 0) return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.dart
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (n == 0) return res;\n  // \u5c3e\u9012\u5f52\u8c03\u7528\n  return tailRecur(n - 1, res + n);\n}\n
    recursion.rs
    /* \u5c3e\u9012\u5f52 */\nfn tail_recur(n: i32, res: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res;\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    tail_recur(n - 1, res + n)\n}\n
    recursion.c
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.kt
    /* \u5c3e\u9012\u5f52 */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // \u6dfb\u52a0 tailrec \u5173\u952e\u8bcd\uff0c\u4ee5\u5f00\u542f\u5c3e\u9012\u5f52\u4f18\u5316\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n)\n}\n
    recursion.rb
    [class]{}-[func]{tail_recur}\n
    recursion.zig
    // \u5c3e\u9012\u5f52\u51fd\u6570\nfn tailRecur(n: i32, res: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0) {\n        return res;\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5c3e\u9012\u5f52\u7684\u6267\u884c\u8fc7\u7a0b\u5982\u56fe 2-5 \u6240\u793a\u3002\u5bf9\u6bd4\u666e\u901a\u9012\u5f52\u548c\u5c3e\u9012\u5f52\uff0c\u4e24\u8005\u7684\u6c42\u548c\u64cd\u4f5c\u7684\u6267\u884c\u70b9\u662f\u4e0d\u540c\u7684\u3002

    • \u666e\u901a\u9012\u5f52\uff1a\u6c42\u548c\u64cd\u4f5c\u662f\u5728\u201c\u5f52\u201d\u7684\u8fc7\u7a0b\u4e2d\u6267\u884c\u7684\uff0c\u6bcf\u5c42\u8fd4\u56de\u540e\u90fd\u8981\u518d\u6267\u884c\u4e00\u6b21\u6c42\u548c\u64cd\u4f5c\u3002
    • \u5c3e\u9012\u5f52\uff1a\u6c42\u548c\u64cd\u4f5c\u662f\u5728\u201c\u9012\u201d\u7684\u8fc7\u7a0b\u4e2d\u6267\u884c\u7684\uff0c\u201c\u5f52\u201d\u7684\u8fc7\u7a0b\u53ea\u9700\u5c42\u5c42\u8fd4\u56de\u3002

    \u56fe 2-5 \u00a0 \u5c3e\u9012\u5f52\u8fc7\u7a0b

    Tip

    \u8bf7\u6ce8\u610f\uff0c\u8bb8\u591a\u7f16\u8bd1\u5668\u6216\u89e3\u91ca\u5668\u5e76\u4e0d\u652f\u6301\u5c3e\u9012\u5f52\u4f18\u5316\u3002\u4f8b\u5982\uff0cPython \u9ed8\u8ba4\u4e0d\u652f\u6301\u5c3e\u9012\u5f52\u4f18\u5316\uff0c\u56e0\u6b64\u5373\u4f7f\u51fd\u6570\u662f\u5c3e\u9012\u5f52\u5f62\u5f0f\uff0c\u4ecd\u7136\u53ef\u80fd\u4f1a\u9047\u5230\u6808\u6ea2\u51fa\u95ee\u9898\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#3_1","title":"3. \u00a0 \u9012\u5f52\u6811","text":"

    \u5f53\u5904\u7406\u4e0e\u201c\u5206\u6cbb\u201d\u76f8\u5173\u7684\u7b97\u6cd5\u95ee\u9898\u65f6\uff0c\u9012\u5f52\u5f80\u5f80\u6bd4\u8fed\u4ee3\u7684\u601d\u8def\u66f4\u52a0\u76f4\u89c2\u3001\u4ee3\u7801\u66f4\u52a0\u6613\u8bfb\u3002\u4ee5\u201c\u6590\u6ce2\u90a3\u5951\u6570\u5217\u201d\u4e3a\u4f8b\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6590\u6ce2\u90a3\u5951\u6570\u5217 \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\) \uff0c\u6c42\u8be5\u6570\u5217\u7684\u7b2c \\(n\\) \u4e2a\u6570\u5b57\u3002

    \u8bbe\u6590\u6ce2\u90a3\u5951\u6570\u5217\u7684\u7b2c \\(n\\) \u4e2a\u6570\u5b57\u4e3a \\(f(n)\\) \uff0c\u6613\u5f97\u4e24\u4e2a\u7ed3\u8bba\u3002

    • \u6570\u5217\u7684\u524d\u4e24\u4e2a\u6570\u5b57\u4e3a \\(f(1) = 0\\) \u548c \\(f(2) = 1\\) \u3002
    • \u6570\u5217\u4e2d\u7684\u6bcf\u4e2a\u6570\u5b57\u662f\u524d\u4e24\u4e2a\u6570\u5b57\u7684\u548c\uff0c\u5373 \\(f(n) = f(n - 1) + f(n - 2)\\) \u3002

    \u6309\u7167\u9012\u63a8\u5173\u7cfb\u8fdb\u884c\u9012\u5f52\u8c03\u7528\uff0c\u5c06\u524d\u4e24\u4e2a\u6570\u5b57\u4f5c\u4e3a\u7ec8\u6b62\u6761\u4ef6\uff0c\u4fbf\u53ef\u5199\u51fa\u9012\u5f52\u4ee3\u7801\u3002\u8c03\u7528 fib(n) \u5373\u53ef\u5f97\u5230\u6590\u6ce2\u90a3\u5951\u6570\u5217\u7684\u7b2c \\(n\\) \u4e2a\u6570\u5b57\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def fib(n: int) -> int:\n    \"\"\"\u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n
    recursion.cpp
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.java
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.cs
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint Fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.go
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunc fib(n int) int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.swift
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunc fib(n: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.js
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunction fib(n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.ts
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunction fib(n: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.dart
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n  // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // \u8fd4\u56de\u7ed3\u679c f(n)\n  return res;\n}\n
    recursion.rs
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfn fib(n: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c\n    res\n}\n
    recursion.c
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.kt
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfun fib(n: Int): Int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.rb
    [class]{}-[func]{fib}\n
    recursion.zig
    // \u6590\u6ce2\u90a3\u5951\u6570\u5217\nfn fib(n: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 or n == 2) {\n        return n - 1;\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    var res: i32 = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u89c2\u5bdf\u4ee5\u4e0a\u4ee3\u7801\uff0c\u6211\u4eec\u5728\u51fd\u6570\u5185\u9012\u5f52\u8c03\u7528\u4e86\u4e24\u4e2a\u51fd\u6570\uff0c\u8fd9\u610f\u5473\u7740\u4ece\u4e00\u4e2a\u8c03\u7528\u4ea7\u751f\u4e86\u4e24\u4e2a\u8c03\u7528\u5206\u652f\u3002\u5982\u56fe 2-6 \u6240\u793a\uff0c\u8fd9\u6837\u4e0d\u65ad\u9012\u5f52\u8c03\u7528\u4e0b\u53bb\uff0c\u6700\u7ec8\u5c06\u4ea7\u751f\u4e00\u68f5\u5c42\u6570\u4e3a \\(n\\) \u7684\u300c\u9012\u5f52\u6811 recursion tree\u300d\u3002

    \u56fe 2-6 \u00a0 \u6590\u6ce2\u90a3\u5951\u6570\u5217\u7684\u9012\u5f52\u6811

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u9012\u5f52\u4f53\u73b0\u4e86\u201c\u5c06\u95ee\u9898\u5206\u89e3\u4e3a\u66f4\u5c0f\u5b50\u95ee\u9898\u201d\u7684\u601d\u7ef4\u8303\u5f0f\uff0c\u8fd9\u79cd\u5206\u6cbb\u7b56\u7565\u81f3\u5173\u91cd\u8981\u3002

    • \u4ece\u7b97\u6cd5\u89d2\u5ea6\u770b\uff0c\u641c\u7d22\u3001\u6392\u5e8f\u3001\u56de\u6eaf\u3001\u5206\u6cbb\u3001\u52a8\u6001\u89c4\u5212\u7b49\u8bb8\u591a\u91cd\u8981\u7b97\u6cd5\u7b56\u7565\u76f4\u63a5\u6216\u95f4\u63a5\u5730\u5e94\u7528\u4e86\u8fd9\u79cd\u601d\u7ef4\u65b9\u5f0f\u3002
    • \u4ece\u6570\u636e\u7ed3\u6784\u89d2\u5ea6\u770b\uff0c\u9012\u5f52\u5929\u7136\u9002\u5408\u5904\u7406\u94fe\u8868\u3001\u6811\u548c\u56fe\u7684\u76f8\u5173\u95ee\u9898\uff0c\u56e0\u4e3a\u5b83\u4eec\u975e\u5e38\u9002\u5408\u7528\u5206\u6cbb\u601d\u60f3\u8fdb\u884c\u5206\u6790\u3002
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#223","title":"2.2.3 \u00a0 \u4e24\u8005\u5bf9\u6bd4","text":"

    \u603b\u7ed3\u4ee5\u4e0a\u5185\u5bb9\uff0c\u5982\u8868 2-1 \u6240\u793a\uff0c\u8fed\u4ee3\u548c\u9012\u5f52\u5728\u5b9e\u73b0\u3001\u6027\u80fd\u548c\u9002\u7528\u6027\u4e0a\u6709\u6240\u4e0d\u540c\u3002

    \u8868 2-1 \u00a0 \u8fed\u4ee3\u4e0e\u9012\u5f52\u7279\u70b9\u5bf9\u6bd4

    \u8fed\u4ee3 \u9012\u5f52 \u5b9e\u73b0\u65b9\u5f0f \u5faa\u73af\u7ed3\u6784 \u51fd\u6570\u8c03\u7528\u81ea\u8eab \u65f6\u95f4\u6548\u7387 \u6548\u7387\u901a\u5e38\u8f83\u9ad8\uff0c\u65e0\u51fd\u6570\u8c03\u7528\u5f00\u9500 \u6bcf\u6b21\u51fd\u6570\u8c03\u7528\u90fd\u4f1a\u4ea7\u751f\u5f00\u9500 \u5185\u5b58\u4f7f\u7528 \u901a\u5e38\u4f7f\u7528\u56fa\u5b9a\u5927\u5c0f\u7684\u5185\u5b58\u7a7a\u95f4 \u7d2f\u79ef\u51fd\u6570\u8c03\u7528\u53ef\u80fd\u4f7f\u7528\u5927\u91cf\u7684\u6808\u5e27\u7a7a\u95f4 \u9002\u7528\u95ee\u9898 \u9002\u7528\u4e8e\u7b80\u5355\u5faa\u73af\u4efb\u52a1\uff0c\u4ee3\u7801\u76f4\u89c2\u3001\u53ef\u8bfb\u6027\u597d \u9002\u7528\u4e8e\u5b50\u95ee\u9898\u5206\u89e3\uff0c\u5982\u6811\u3001\u56fe\u3001\u5206\u6cbb\u3001\u56de\u6eaf\u7b49\uff0c\u4ee3\u7801\u7ed3\u6784\u7b80\u6d01\u3001\u6e05\u6670

    Tip

    \u5982\u679c\u611f\u89c9\u4ee5\u4e0b\u5185\u5bb9\u7406\u89e3\u56f0\u96be\uff0c\u53ef\u4ee5\u5728\u8bfb\u5b8c\u201c\u6808\u201d\u7ae0\u8282\u540e\u518d\u6765\u590d\u4e60\u3002

    \u90a3\u4e48\uff0c\u8fed\u4ee3\u548c\u9012\u5f52\u5177\u6709\u4ec0\u4e48\u5185\u5728\u8054\u7cfb\u5462\uff1f\u4ee5\u4e0a\u8ff0\u9012\u5f52\u51fd\u6570\u4e3a\u4f8b\uff0c\u6c42\u548c\u64cd\u4f5c\u5728\u9012\u5f52\u7684\u201c\u5f52\u201d\u9636\u6bb5\u8fdb\u884c\u3002\u8fd9\u610f\u5473\u7740\u6700\u521d\u88ab\u8c03\u7528\u7684\u51fd\u6570\u5b9e\u9645\u4e0a\u662f\u6700\u540e\u5b8c\u6210\u5176\u6c42\u548c\u64cd\u4f5c\u7684\uff0c\u8fd9\u79cd\u5de5\u4f5c\u673a\u5236\u4e0e\u6808\u7684\u201c\u5148\u5165\u540e\u51fa\u201d\u539f\u5219\u5f02\u66f2\u540c\u5de5\u3002

    \u4e8b\u5b9e\u4e0a\uff0c\u201c\u8c03\u7528\u6808\u201d\u548c\u201c\u6808\u5e27\u7a7a\u95f4\u201d\u8fd9\u7c7b\u9012\u5f52\u672f\u8bed\u5df2\u7ecf\u6697\u793a\u4e86\u9012\u5f52\u4e0e\u6808\u4e4b\u95f4\u7684\u5bc6\u5207\u5173\u7cfb\u3002

    1. \u9012\uff1a\u5f53\u51fd\u6570\u88ab\u8c03\u7528\u65f6\uff0c\u7cfb\u7edf\u4f1a\u5728\u201c\u8c03\u7528\u6808\u201d\u4e0a\u4e3a\u8be5\u51fd\u6570\u5206\u914d\u65b0\u7684\u6808\u5e27\uff0c\u7528\u4e8e\u5b58\u50a8\u51fd\u6570\u7684\u5c40\u90e8\u53d8\u91cf\u3001\u53c2\u6570\u3001\u8fd4\u56de\u5730\u5740\u7b49\u6570\u636e\u3002
    2. \u5f52\uff1a\u5f53\u51fd\u6570\u5b8c\u6210\u6267\u884c\u5e76\u8fd4\u56de\u65f6\uff0c\u5bf9\u5e94\u7684\u6808\u5e27\u4f1a\u88ab\u4ece\u201c\u8c03\u7528\u6808\u201d\u4e0a\u79fb\u9664\uff0c\u6062\u590d\u4e4b\u524d\u51fd\u6570\u7684\u6267\u884c\u73af\u5883\u3002

    \u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u8c03\u7528\u6808\u7684\u884c\u4e3a\uff0c\u4ece\u800c\u5c06\u9012\u5f52\u8f6c\u5316\u4e3a\u8fed\u4ee3\u5f62\u5f0f\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def for_loop_recur(n: int) -> int:\n    \"\"\"\u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52\"\"\"\n    # \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack = []\n    res = 0\n    # \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in range(n, 0, -1):\n        # \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.append(i)\n    # \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while stack:\n        # \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n
    recursion.cpp
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack<int> stack;\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (!stack.empty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.java
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    Stack<Integer> stack = new Stack<>();\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (!stack.isEmpty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.cs
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint ForLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    Stack<int> stack = new();\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.Push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.Count > 0) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.go
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunc forLoopRecur(n int) int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack := list.New()\n    res := 0\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i := n; i > 0; i-- {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.PushBack(i)\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    for stack.Len() != 0 {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.swift
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunc forLoopRecur(n: Int) -> Int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    var stack: [Int] = []\n    var res = 0\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in (1 ... n).reversed() {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.append(i)\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while !stack.isEmpty {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.js
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunction forLoopRecur(n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    const stack = [];\n    let res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (let i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.length) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.ts
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunction forLoopRecur(n: number): number {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808 \n    const stack: number[] = [];\n    let res: number = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (let i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.length) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.dart
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n  // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n  List<int> stack = [];\n  int res = 0;\n  // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n  for (int i = n; i > 0; i--) {\n    // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n    stack.add(i);\n  }\n  // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n  while (!stack.isEmpty) {\n    // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n
    recursion.rs
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfn for_loop_recur(n: i32) -> i32 {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in (1..=n).rev() {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while !stack.is_empty() {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n
    recursion.c
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    int stack[1000]; // \u501f\u52a9\u4e00\u4e2a\u5927\u6570\u7ec4\u6765\u6a21\u62df\u6808\n    int top = -1;    // \u6808\u9876\u7d22\u5f15\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack[1 + top++] = i;\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (top >= 0) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.kt
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfun forLoopRecur(n: Int): Int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    val stack = Stack<Int>()\n    var res = 0\n    // \u9012: \u9012\u5f52\u8c03\u7528\n    for (i in n downTo 0) {\n        stack.push(i)\n    }\n    // \u5f52: \u8fd4\u56de\u7ed3\u679c\n    while (stack.isNotEmpty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.rb
    [class]{}-[func]{for_loop_recur}\n
    recursion.zig
    // \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52\nfn forLoopRecur(comptime n: i32) i32 {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    var stack: [n]i32 = undefined;\n    var res: i32 = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    var i: usize = n;\n    while (i > 0) {\n        stack[i - 1] = @intCast(i);\n        i -= 1;\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    var index: usize = n;\n    while (index > 0) {\n        index -= 1;\n        res += stack[index];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u89c2\u5bdf\u4ee5\u4e0a\u4ee3\u7801\uff0c\u5f53\u9012\u5f52\u8f6c\u5316\u4e3a\u8fed\u4ee3\u540e\uff0c\u4ee3\u7801\u53d8\u5f97\u66f4\u52a0\u590d\u6742\u4e86\u3002\u5c3d\u7ba1\u8fed\u4ee3\u548c\u9012\u5f52\u5728\u5f88\u591a\u60c5\u51b5\u4e0b\u53ef\u4ee5\u4e92\u76f8\u8f6c\u5316\uff0c\u4f46\u4e0d\u4e00\u5b9a\u503c\u5f97\u8fd9\u6837\u505a\uff0c\u6709\u4ee5\u4e0b\u4e24\u70b9\u539f\u56e0\u3002

    • \u8f6c\u5316\u540e\u7684\u4ee3\u7801\u53ef\u80fd\u66f4\u52a0\u96be\u4ee5\u7406\u89e3\uff0c\u53ef\u8bfb\u6027\u66f4\u5dee\u3002
    • \u5bf9\u4e8e\u67d0\u4e9b\u590d\u6742\u95ee\u9898\uff0c\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\u7684\u884c\u4e3a\u53ef\u80fd\u975e\u5e38\u56f0\u96be\u3002

    \u603b\u4e4b\uff0c\u9009\u62e9\u8fed\u4ee3\u8fd8\u662f\u9012\u5f52\u53d6\u51b3\u4e8e\u7279\u5b9a\u95ee\u9898\u7684\u6027\u8d28\u3002\u5728\u7f16\u7a0b\u5b9e\u8df5\u4e2d\uff0c\u6743\u8861\u4e24\u8005\u7684\u4f18\u52a3\u5e76\u6839\u636e\u60c5\u5883\u9009\u62e9\u5408\u9002\u7684\u65b9\u6cd5\u81f3\u5173\u91cd\u8981\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/","title":"2.1 \u00a0 \u7b97\u6cd5\u6548\u7387\u8bc4\u4f30","text":"

    \u5728\u7b97\u6cd5\u8bbe\u8ba1\u4e2d\uff0c\u6211\u4eec\u5148\u540e\u8ffd\u6c42\u4ee5\u4e0b\u4e24\u4e2a\u5c42\u9762\u7684\u76ee\u6807\u3002

    1. \u627e\u5230\u95ee\u9898\u89e3\u6cd5\uff1a\u7b97\u6cd5\u9700\u8981\u5728\u89c4\u5b9a\u7684\u8f93\u5165\u8303\u56f4\u5185\u53ef\u9760\u5730\u6c42\u5f97\u95ee\u9898\u7684\u6b63\u786e\u89e3\u3002
    2. \u5bfb\u6c42\u6700\u4f18\u89e3\u6cd5\uff1a\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

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5728\u80fd\u591f\u89e3\u51b3\u95ee\u9898\u7684\u524d\u63d0\u4e0b\uff0c\u7b97\u6cd5\u6548\u7387\u5df2\u6210\u4e3a\u8861\u91cf\u7b97\u6cd5\u4f18\u52a3\u7684\u4e3b\u8981\u8bc4\u4ef7\u6307\u6807\uff0c\u5b83\u5305\u62ec\u4ee5\u4e0b\u4e24\u4e2a\u7ef4\u5ea6\u3002

    • \u65f6\u95f4\u6548\u7387\uff1a\u7b97\u6cd5\u8fd0\u884c\u901f\u5ea6\u7684\u5feb\u6162\u3002
    • \u7a7a\u95f4\u6548\u7387\uff1a\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\u800c\u6709\u6548\u5730\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\u81f3\u5173\u91cd\u8981\uff0c\u56e0\u4e3a\u53ea\u6709\u8fd9\u6837\uff0c\u6211\u4eec\u624d\u80fd\u5c06\u5404\u79cd\u7b97\u6cd5\u8fdb\u884c\u5bf9\u6bd4\uff0c\u8fdb\u800c\u6307\u5bfc\u7b97\u6cd5\u8bbe\u8ba1\u4e0e\u4f18\u5316\u8fc7\u7a0b\u3002

    \u6548\u7387\u8bc4\u4f30\u65b9\u6cd5\u4e3b\u8981\u5206\u4e3a\u4e24\u79cd\uff1a\u5b9e\u9645\u6d4b\u8bd5\u3001\u7406\u8bba\u4f30\u7b97\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/#211","title":"2.1.1 \u00a0 \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\u6700\u76f4\u63a5\u7684\u65b9\u6cd5\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\u7684\u5c40\u9650\u6027\u3002

    \u4e00\u65b9\u9762\uff0c\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\u3002\u6bd4\u5982\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\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\u7edf\u8ba1\u5e73\u5747\u6548\u7387\uff0c\u800c\u8fd9\u662f\u4e0d\u73b0\u5b9e\u7684\u3002

    \u53e6\u4e00\u65b9\u9762\uff0c\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\u5728\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5c0f\u65f6\uff0c\u7b97\u6cd5 A \u7684\u8fd0\u884c\u65f6\u95f4\u6bd4\u7b97\u6cd5 B \u77ed\uff1b\u800c\u5728\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5927\u65f6\uff0c\u6d4b\u8bd5\u7ed3\u679c\u53ef\u80fd\u6070\u6070\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\u800c\u8fd9\u9700\u8981\u8017\u8d39\u5927\u91cf\u7684\u8ba1\u7b97\u8d44\u6e90\u3002

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

    \u7531\u4e8e\u5b9e\u9645\u6d4b\u8bd5\u5177\u6709\u8f83\u5927\u7684\u5c40\u9650\u6027\uff0c\u56e0\u6b64\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\u6e10\u8fd1\u590d\u6742\u5ea6\u5206\u6790 asymptotic complexity analysis\u300d\uff0c\u7b80\u79f0\u300c\u590d\u6742\u5ea6\u5206\u6790\u300d\u3002

    \u590d\u6742\u5ea6\u5206\u6790\u80fd\u591f\u4f53\u73b0\u7b97\u6cd5\u8fd0\u884c\u6240\u9700\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u8d44\u6e90\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e4b\u95f4\u7684\u5173\u7cfb\u3002\u5b83\u63cf\u8ff0\u4e86\u968f\u7740\u8f93\u5165\u6570\u636e\u5927\u5c0f\u7684\u589e\u52a0\uff0c\u7b97\u6cd5\u6267\u884c\u6240\u9700\u65f6\u95f4\u548c\u7a7a\u95f4\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\u3002

    • \u201c\u65f6\u95f4\u548c\u7a7a\u95f4\u8d44\u6e90\u201d\u5206\u522b\u5bf9\u5e94\u300c\u65f6\u95f4\u590d\u6742\u5ea6 time complexity\u300d\u548c\u300c\u7a7a\u95f4\u590d\u6742\u5ea6 space complexity\u300d\u3002
    • \u201c\u968f\u7740\u8f93\u5165\u6570\u636e\u5927\u5c0f\u7684\u589e\u52a0\u201d\u610f\u5473\u7740\u590d\u6742\u5ea6\u53cd\u6620\u4e86\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u4e0e\u8f93\u5165\u6570\u636e\u4f53\u91cf\u4e4b\u95f4\u7684\u5173\u7cfb\u3002
    • \u201c\u65f6\u95f4\u548c\u7a7a\u95f4\u7684\u589e\u957f\u8d8b\u52bf\u201d\u8868\u793a\u590d\u6742\u5ea6\u5206\u6790\u5173\u6ce8\u7684\u4e0d\u662f\u8fd0\u884c\u65f6\u95f4\u6216\u5360\u7528\u7a7a\u95f4\u7684\u5177\u4f53\u503c\uff0c\u800c\u662f\u65f6\u95f4\u6216\u7a7a\u95f4\u589e\u957f\u7684\u201c\u5feb\u6162\u201d\u3002

    \u590d\u6742\u5ea6\u5206\u6790\u514b\u670d\u4e86\u5b9e\u9645\u6d4b\u8bd5\u65b9\u6cd5\u7684\u5f0a\u7aef\uff0c\u4f53\u73b0\u5728\u4ee5\u4e0b\u4e24\u4e2a\u65b9\u9762\u3002

    • \u5b83\u72ec\u7acb\u4e8e\u6d4b\u8bd5\u73af\u5883\uff0c\u5206\u6790\u7ed3\u679c\u9002\u7528\u4e8e\u6240\u6709\u8fd0\u884c\u5e73\u53f0\u3002
    • \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

    Tip

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

    \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\u4f7f\u6211\u4eec\u53ef\u4ee5\u8861\u91cf\u6267\u884c\u67d0\u4e2a\u7b97\u6cd5\u6240\u9700\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u8d44\u6e90\uff0c\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\u6700\u5148\u4ecb\u7ecd\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\u96be\u4ee5\u907f\u514d\u8981\u5206\u6790\u5176\u8fd0\u884c\u901f\u5ea6\u548c\u7a7a\u95f4\u4f7f\u7528\u60c5\u51b5\u3002

    \u7efc\u4e0a\u6240\u8ff0\uff0c\u5efa\u8bae\u4f60\u5728\u6df1\u5165\u5b66\u4e60\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u4e4b\u524d\uff0c\u5148\u5bf9\u590d\u6742\u5ea6\u5206\u6790\u5efa\u7acb\u521d\u6b65\u7684\u4e86\u89e3\uff0c\u4ee5\u4fbf\u80fd\u591f\u5b8c\u6210\u7b80\u5355\u7b97\u6cd5\u7684\u590d\u6742\u5ea6\u5206\u6790\u3002

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

    \u300c\u7a7a\u95f4\u590d\u6742\u5ea6 space complexity\u300d\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u5360\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\uff0c\u53ea\u9700\u5c06\u201c\u8fd0\u884c\u65f6\u95f4\u201d\u66ff\u6362\u4e3a\u201c\u5360\u7528\u5185\u5b58\u7a7a\u95f4\u201d\u3002

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

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

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

    \u4e00\u822c\u60c5\u51b5\u4e0b\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u7edf\u8ba1\u8303\u56f4\u662f\u201c\u6682\u5b58\u7a7a\u95f4\u201d\u52a0\u4e0a\u201c\u8f93\u51fa\u7a7a\u95f4\u201d\u3002

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

    • \u6682\u5b58\u6570\u636e\uff1a\u7528\u4e8e\u4fdd\u5b58\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u5404\u79cd\u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u7b49\u3002
    • \u6808\u5e27\u7a7a\u95f4\uff1a\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
    • \u6307\u4ee4\u7a7a\u95f4\uff1a\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

    \u5728\u5206\u6790\u4e00\u6bb5\u7a0b\u5e8f\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u65f6\uff0c\u6211\u4eec\u901a\u5e38\u7edf\u8ba1\u6682\u5b58\u6570\u636e\u3001\u6808\u5e27\u7a7a\u95f4\u548c\u8f93\u51fa\u6570\u636e\u4e09\u90e8\u5206\uff0c\u5982\u56fe 2-15 \u6240\u793a\u3002

    \u56fe 2-15 \u00a0 \u7b97\u6cd5\u4f7f\u7528\u7684\u76f8\u5173\u7a7a\u95f4

    \u76f8\u5173\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class Node:\n    \"\"\"\u7c7b\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # \u8282\u70b9\u503c\n        self.next: Node | None = None  # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n\ndef function() -> int:\n    \"\"\"\u51fd\u6570\"\"\"\n    # \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n\ndef algorithm(n) -> int:  # \u8f93\u5165\u6570\u636e\n    A = 0                 # \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff0c\u4e00\u822c\u7528\u5927\u5199\u5b57\u6bcd\u8868\u793a\uff09\n    b = 0                 # \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    node = Node(0)        # \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    c = function()        # \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return A + b + c      # \u8f93\u51fa\u6570\u636e\n
    /* \u7ed3\u6784\u4f53 */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nint algorithm(int n) {        // \u8f93\u5165\u6570\u636e\n    const int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    int b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    Node* node = new Node(0); // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    int c = func();           // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* \u51fd\u6570 */\nint function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nint algorithm(int n) {        // \u8f93\u5165\u6570\u636e\n    final int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    int b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    Node node = new Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    int c = function();       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* \u51fd\u6570 */\nint Function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nint Algorithm(int n) {        // \u8f93\u5165\u6570\u636e\n    const int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    int b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    Node node = new(0);       // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    int c = Function();       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7ed3\u6784\u4f53 */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* \u521b\u5efa node \u7ed3\u6784\u4f53  */\nfunc newNode(val int) *node {\n    return &node{val: val}\n}\n\n/* \u51fd\u6570 */\nfunc function() int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\nfunc algorithm(n int) int { // \u8f93\u5165\u6570\u636e\n    const a = 0             // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    b := 0                  // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    newNode(0)              // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    c := function()         // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c        // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* \u51fd\u6570 */\nfunc function() -> Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\nfunc algorithm(n: Int) -> Int { // \u8f93\u5165\u6570\u636e\n    let a = 0             // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    var b = 0             // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    let node = Node(x: 0) // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    let c = function()    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c      // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\n        this.next = null;                       // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n\n/* \u51fd\u6570 */\nfunction constFunc() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\nfunction algorithm(n) {       // \u8f93\u5165\u6570\u636e\n    const a = 0;              // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    let b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    const node = new Node(0); // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    const c = constFunc();    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\n        this.next = null;                       // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n\n/* \u51fd\u6570 */\nfunction constFunc(): number {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\nfunction algorithm(n: number): number { // \u8f93\u5165\u6570\u636e\n    const a = 0;                        // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    let b = 0;                          // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    const node = new Node(0);           // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    const c = constFunc();              // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;                   // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* \u51fd\u6570 */\nint function() {\n  // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n  return 0;\n}\n\nint algorithm(int n) {  // \u8f93\u5165\u6570\u636e\n  const int a = 0;      // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n  int b = 0;            // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n  Node node = Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n  int c = function();   // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n  return a + b + c;     // \u8f93\u51fa\u6570\u636e\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* \u7ed3\u6784\u4f53 */\nstruct Node {\n    val: i32,\n    next: Option<Rc<RefCell<Node>>>,\n}\n\n/* \u521b\u5efa Node \u7ed3\u6784\u4f53 */\nimpl Node {\n    fn new(val: i32) -> Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* \u51fd\u6570 */\nfn function() -> i32 {      \n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nfn algorithm(n: i32) -> i32 {       // \u8f93\u5165\u6570\u636e\n    const a: i32 = 0;               // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    let mut b = 0;                  // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    let node = Node::new(0);        // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    let c = function();             // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;               // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nint algorithm(int n) { // \u8f93\u5165\u6570\u636e\n    const int a = 0;   // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    int b = 0;         // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    int c = func();    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;  // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* \u51fd\u6570 */\nfun function(): Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // \u8f93\u5165\u6570\u636e\n    val a = 0                // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    var b = 0                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    val node = Node(0)       // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    val c = function()       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c         // \u8f93\u51fa\u6570\u636e\n}\n
    \n
    \n
    "},{"location":"chapter_computational_complexity/space_complexity/#242","title":"2.4.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\u9700\u5c06\u7edf\u8ba1\u5bf9\u8c61\u4ece\u201c\u64cd\u4f5c\u6570\u91cf\u201d\u8f6c\u4e3a\u201c\u4f7f\u7528\u7a7a\u95f4\u5927\u5c0f\u201d\u3002

    \u800c\u4e0e\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u540c\u7684\u662f\uff0c\u6211\u4eec\u901a\u5e38\u53ea\u5173\u6ce8\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u3002\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

    \u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff0c\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e2d\u7684\u201c\u6700\u5dee\u201d\u6709\u4e24\u5c42\u542b\u4e49\u3002

    1. \u4ee5\u6700\u5dee\u8f93\u5165\u6570\u636e\u4e3a\u51c6\uff1a\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\uff0c\u56e0\u6b64\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002
    2. \u4ee5\u7b97\u6cd5\u8fd0\u884c\u4e2d\u7684\u5cf0\u503c\u5185\u5b58\u4e3a\u51c6\uff1a\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\uff0c\u56e0\u6b64\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n > 10:\n        nums = [0] * n  # O(n)\n
    void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector<int> b(10000);    // O(1)\n    if (n > 10)\n        vector<int> nums(n); // O(n)\n}\n
    void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n > 10)\n        int[] nums = new int[n]; // O(n)\n}\n
    void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n > 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n
    func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n > 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n
    func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n > 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n
    function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n > 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n
    function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n > 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n
    void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List<int> b = List.filled(10000, 0);  // O(1)\n  if (n > 10) {\n    List<int> nums = List.filled(n, 0); // O(n)\n  }\n}\n
    fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n > 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n
    void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n > 10)\n        int nums[n] = {0};   // O(n)\n}\n
    fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n > 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n
    \n
    \n

    \u5728\u9012\u5f52\u51fd\u6570\u4e2d\uff0c\u9700\u8981\u6ce8\u610f\u7edf\u8ba1\u6808\u5e27\u7a7a\u95f4\u3002\u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def function() -> int:\n    # \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n\ndef loop(n: int):\n    \"\"\"\u5faa\u73af\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"\u9012\u5f52\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n
    int func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    int function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        function();\n    }\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    int Function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i < n; i++) {\n        Function();\n    }\n}\n/* \u9012\u5f52 O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n
    func function() int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5faa\u73af O(1) */\nfunc loop(n int) {\n    for i := 0; i < n; i++ {\n        function()\n    }\n}\n\n/* \u9012\u5f52 O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n
    @discardableResult\nfunc function() -> Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5faa\u73af O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..< n {\n        function()\n    }\n}\n\n/* \u9012\u5f52 O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n
    function constFunc() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nfunction loop(n) {\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n/* \u9012\u5f52 O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n
    function constFunc(): number {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n/* \u9012\u5f52 O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n
    int function() {\n  // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n  return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\n  for (int i = 0; i < n; i++) {\n    function();\n  }\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  return recur(n - 1);\n}\n
    fn function() -> i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* \u9012\u5f52 O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n
    int func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    fun function(): Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n/* \u5faa\u73af O(1) */\nfun loop(n: Int) {\n    for (i in 0..<n) {\n        function()\n    }\n}\n/* \u9012\u5f52 O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n
    \n
    \n

    \u51fd\u6570 loop() \u548c recur() \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n)\\) \uff0c\u4f46\u7a7a\u95f4\u590d\u6742\u5ea6\u4e0d\u540c\u3002

    • \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
    • \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
    "},{"location":"chapter_computational_complexity/space_complexity/#243","title":"2.4.3 \u00a0 \u5e38\u89c1\u7c7b\u578b","text":"

    \u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u56fe 2-16 \u5c55\u793a\u4e86\u5e38\u89c1\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u7c7b\u578b\uff08\u4ece\u4f4e\u5230\u9ad8\u6392\u5217\uff09\u3002

    \\[ \\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} \\]

    \u56fe 2-16 \u00a0 \u5e38\u89c1\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u7c7b\u578b

    "},{"location":"chapter_computational_complexity/space_complexity/#1-o1","title":"1. \u00a0 \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\u56e0\u6b64\u4e0d\u4f1a\u7d2f\u79ef\u5360\u7528\u7a7a\u95f4\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def function() -> int:\n    \"\"\"\u51fd\u6570\"\"\"\n    # \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n\ndef constant(n: int):\n    \"\"\"\u5e38\u6570\u9636\"\"\"\n    # \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in range(n):\n        c = 0\n    # \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in range(n):\n        function()\n
    space_complexity.cpp
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const int a = 0;\n    int b = 0;\n    vector<int> nums(10000);\n    ListNode node(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n
    space_complexity.java
    /* \u51fd\u6570 */\nint function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        function();\n    }\n}\n
    space_complexity.cs
    /* \u51fd\u6570 */\nint Function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid Constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        Function();\n    }\n}\n
    space_complexity.go
    /* \u51fd\u6570 */\nfunc function() int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfunc spaceConstant(n int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    var c int\n    for i := 0; i < n; i++ {\n        c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for i := 0; i < n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n
    space_complexity.swift
    /* \u51fd\u6570 */\n@discardableResult\nfunc function() -> Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfunc constant(n: Int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in 0 ..< n {\n        let c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in 0 ..< n {\n        function()\n    }\n}\n
    space_complexity.js
    /* \u51fd\u6570 */\nfunction constFunc() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nfunction constant(n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        const c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n
    space_complexity.ts
    /* \u51fd\u6570 */\nfunction constFunc(): number {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nfunction constant(n: number): void {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        const c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n
    space_complexity.dart
    /* \u51fd\u6570 */\nint function() {\n  // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n  return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n  // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n  final int a = 0;\n  int b = 0;\n  List<int> nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n  for (var i = 0; i < n; i++) {\n    int c = 0;\n  }\n  // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n  for (var i = 0; i < n; i++) {\n    function();\n  }\n}\n
    space_complexity.rs
    /* \u51fd\u6570 */\nfn function() -> i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\n#[allow(unused)]\nfn constant(n: i32) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for i in 0..n {\n        let c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for i in 0..n {\n        function();\n    }\n}\n
    space_complexity.c
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n
    space_complexity.kt
    /* \u51fd\u6570 */\nfun function(): Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfun constant(n: Int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (i in 0..<n) {\n        val c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (i in 0..<n) {\n        function()\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{function}\n\n[class]{}-[func]{constant}\n
    space_complexity.zig
    // \u51fd\u6570\nfn function() i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n// \u5e38\u6570\u9636\nfn constant(n: i32) void {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a: i32 = 0;\n    var b: i32 = 0;\n    var nums = [_]i32{0}**10000;\n    var node = inc.ListNode(i32){.val = 0};\n    var i: i32 = 0;\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    while (i < n) : (i += 1) {\n        var c: i32 = 0;\n        _ = c;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    i = 0;\n    while (i < n) : (i += 1) {\n        _ = function();\n    }\n    _ = a;\n    _ = b;\n    _ = nums;\n    _ = node;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_computational_complexity/space_complexity/#2-on","title":"2. \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def linear(n: int):\n    \"\"\"\u7ebf\u6027\u9636\"\"\"\n    # \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    nums = [0] * n\n    # \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\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\n    vector<int> nums(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    vector<ListNode> nodes;\n    for (int i = 0; i < n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    unordered_map<int, string> map;\n    for (int i = 0; i < n; i++) {\n        map[i] = to_string(i);\n    }\n}\n
    space_complexity.java
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    int[] nums = new int[n];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    List<ListNode> nodes = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    Map<Integer, String> map = new HashMap<>();\n    for (int i = 0; i < n; i++) {\n        map.put(i, String.valueOf(i));\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\n    int[] nums = new int[n];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    List<ListNode> nodes = [];\n    for (int i = 0; i < n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    Dictionary<int, string> map = [];\n    for (int i = 0; i < n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\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\n    var nodes []*node\n    for i := 0; i < n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    m := make(map[int]string, n)\n    for i := 0; i < n; i++ {\n        m[i] = strconv.Itoa(i)\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\n    let nums = Array(repeating: 0, count: n)\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let nodes = (0 ..< n).map { ListNode(x: $0) }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, \"\\($0)\") })\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\n    const nums = new Array(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const nodes = [];\n    for (let i = 0; i < n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const map = new Map();\n    for (let i = 0; i < n; i++) {\n        map.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\n    const nums = new Array(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const nodes: ListNode[] = [];\n    for (let i = 0; i < n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const map = new Map();\n    for (let i = 0; i < n; i++) {\n        map.set(i, i.toString());\n    }\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\n  List<int> nums = List.filled(n, 0);\n  // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n  List<ListNode> nodes = [];\n  for (var i = 0; i < n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n  Map<int, String> map = HashMap();\n  for (var i = 0; i < n; i++) {\n    map.putIfAbsent(i, () => i.toString());\n  }\n}\n
    space_complexity.rs
    /* \u7ebf\u6027\u9636 */\n#[allow(unused)]\nfn linear(n: i32) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut nums = vec![0; n as usize];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n
    space_complexity.c
    /* \u54c8\u5e0c\u8868 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n} HashTable;\n\n/* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i < n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // \u5185\u5b58\u91ca\u653e\n    for (int i = 0; i < n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    HashTable *h = NULL;\n    for (int i = 0; i < n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp->key = i;\n        tmp->val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // \u5185\u5b58\u91ca\u653e\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n
    space_complexity.kt
    /* \u7ebf\u6027\u9636 */\nfun linear(n: Int) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    val nums = Array(n) { 0 }\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    val nodes = mutableListOf<ListNode>()\n    for (i in 0..<n) {\n        nodes.add(ListNode(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    val map = mutableMapOf<Int, String>()\n    for (i in 0..<n) {\n        map[i] = i.toString()\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{linear}\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\n    var nums = [_]i32{0}**n;\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    var nodes = std.ArrayList(i32).init(std.heap.page_allocator);\n    defer nodes.deinit();\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        try nodes.append(i);\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    var map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator);\n    defer map.deinit();\n    var j: i32 = 0;\n    while (j < n) : (j += 1) {\n        const string = try std.fmt.allocPrint(std.heap.page_allocator, \"{d}\", .{j});\n        defer std.heap.page_allocator.free(string);\n        try map.put(i, string);\n    }\n    _ = nums;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 2-17 \u6240\u793a\uff0c\u6b64\u51fd\u6570\u7684\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u5373\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684 linear_recur() \u51fd\u6570\uff0c\u4f7f\u7528 \\(O(n)\\) \u5927\u5c0f\u7684\u6808\u5e27\u7a7a\u95f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def linear_recur(n: int):\n    \"\"\"\u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    print(\"\u9012\u5f52 n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n
    space_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    cout << \"\u9012\u5f52 n = \" << n << endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    System.out.println(\"\u9012\u5f52 n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"\u9012\u5f52 n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n
    space_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"\u9012\u5f52 n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n
    space_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc linearRecur(n: Int) {\n    print(\"\u9012\u5f52 n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n
    space_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n) {\n    console.log(`\u9012\u5f52 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n: number): void {\n    console.log(`\u9012\u5f52 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n  print('\u9012\u5f52 n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n
    space_complexity.rs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn linear_recur(n: i32) {\n    println!(\"\u9012\u5f52 n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n
    space_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    printf(\"\u9012\u5f52 n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.kt
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun linearRecur(n: Int) {\n    println(\"\u9012\u5f52 n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n
    space_complexity.rb
    [class]{}-[func]{linear_recur}\n
    space_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn linearRecur(comptime n: i32) void {\n    std.debug.print(\"\u9012\u5f52 n = {}\\n\", .{n});\n    if (n == 1) return;\n    linearRecur(n - 1);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-17 \u00a0 \u9012\u5f52\u51fd\u6570\u4ea7\u751f\u7684\u7ebf\u6027\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/space_complexity/#3-on2","title":"3. \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def quadratic(n: int):\n    \"\"\"\u5e73\u65b9\u9636\"\"\"\n    # \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    num_matrix = [[0] * n for _ in range(n)]\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    vector<vector<int>> numMatrix;\n    for (int i = 0; i < n; i++) {\n        vector<int> tmp;\n        for (int j = 0; j < n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n
    space_complexity.java
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    int[][] numMatrix = new int[n][n];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    List<List<Integer>> numList = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        List<Integer> tmp = new ArrayList<>();\n        for (int j = 0; j < n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636 */\nvoid Quadratic(int n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    int[,] numMatrix = new int[n, n];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    List<List<int>> numList = [];\n    for (int i = 0; i < n; i++) {\n        List<int> tmp = [];\n        for (int j = 0; j < n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n
    space_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc spaceQuadratic(n int) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    numMatrix := make([][]int, n)\n    for i := 0; i < n; i++ {\n        numMatrix[i] = make([]int, n)\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\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() => Array(n).fill(null));\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numList = [];\n    for (let i = 0; i < n; i++) {\n        const tmp = [];\n        for (let j = 0; j < n; j++) {\n            tmp.push(0);\n        }\n        numList.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\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() => Array(n).fill(null));\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numList = [];\n    for (let i = 0; i < n; i++) {\n        const tmp = [];\n        for (let j = 0; j < n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n  // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n  List<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));\n  // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n  List<List<int>> numList = [];\n  for (var i = 0; i < n; i++) {\n    List<int> tmp = [];\n    for (int j = 0; j < n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n
    space_complexity.rs
    /* \u5e73\u65b9\u9636 */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.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\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i < n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j < n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // \u5185\u5b58\u91ca\u653e\n    for (int i = 0; i < n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n
    space_complexity.kt
    /* \u5e73\u65b9\u9636 */\nfun quadratic(n: Int) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    val numMatrix: Array<Array<Int>?> = arrayOfNulls(n)\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    val numList: MutableList<MutableList<Int>> = arrayListOf()\n    for (i in 0..<n) {\n        val tmp = mutableListOf<Int>()\n        for (j in 0..<n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{quadratic}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) !void {\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    var nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator);\n    defer nodes.deinit();\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        var tmp = std.ArrayList(i32).init(std.heap.page_allocator);\n        defer tmp.deinit();\n        var j: i32 = 0;\n        while (j < n) : (j += 1) {\n            try tmp.append(0);\n        }\n        try nodes.append(tmp);\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 2-18 \u6240\u793a\uff0c\u8be5\u51fd\u6570\u7684\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u5728\u6bcf\u4e2a\u9012\u5f52\u51fd\u6570\u4e2d\u90fd\u521d\u59cb\u5316\u4e86\u4e00\u4e2a\u6570\u7ec4\uff0c\u957f\u5ea6\u5206\u522b\u4e3a \\(n\\)\u3001\\(n-1\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \uff0c\u5e73\u5747\u957f\u5ea6\u4e3a \\(n / 2\\) \uff0c\u56e0\u6b64\u603b\u4f53\u5360\u7528 \\(O(n^2)\\) \u7a7a\u95f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def quadratic_recur(n: int) -> int:\n    \"\"\"\u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n <= 0:\n        return 0\n    # \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    vector<int> nums(n);\n    cout << \"\u9012\u5f52 n = \" << n << \" \u4e2d\u7684 nums \u957f\u5ea6 = \" << nums.size() << endl;\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint QuadraticRecur(int n) {\n    if (n <= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n
    space_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceQuadraticRecur(n int) int {\n    if n <= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n
    space_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\n@discardableResult\nfunc quadraticRecur(n: Int) -> Int {\n    if n <= 0 {\n        return 0\n    }\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"\u9012\u5f52 n = \\(n) \u4e2d\u7684 nums \u957f\u5ea6 = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n) {\n    if (n <= 0) return 0;\n    const nums = new Array(n);\n    console.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n: number): number {\n    if (n <= 0) return 0;\n    const nums = new Array(n);\n    console.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n  if (n <= 0) return 0;\n  List<int> nums = List.filled(n, 0);\n  print('\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n
    space_complexity.rs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn quadratic_recur(n: i32) -> i32 {\n    if n <= 0 {\n        return 0;\n    };\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n
    space_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n
    space_complexity.kt
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n <= 0)\n        return 0\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n
    space_complexity.rb
    [class]{}-[func]{quadratic_recur}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn quadraticRecur(comptime n: i32) i32 {\n    if (n <= 0) return 0;\n    var nums = [_]i32{0}**n;\n    std.debug.print(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\\n\", .{n, nums.len});\n    return quadraticRecur(n - 1);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-18 \u00a0 \u9012\u5f52\u51fd\u6570\u4ea7\u751f\u7684\u5e73\u65b9\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

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

    \u6307\u6570\u9636\u5e38\u89c1\u4e8e\u4e8c\u53c9\u6811\u3002\u89c2\u5bdf\u56fe 2-19 \uff0c\u5c42\u6570\u4e3a \\(n\\) \u7684\u201c\u6ee1\u4e8c\u53c9\u6811\u201d\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(2^n - 1\\) \uff0c\u5360\u7528 \\(O(2^n)\\) \u7a7a\u95f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def build_tree(n: int) -> TreeNode | None:\n    \"\"\"\u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n
    space_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root->left = buildTree(n - 1);\n    root->right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.java
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n
    space_complexity.go
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n
    space_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n: Int) -> TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n
    space_complexity.js
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n
    space_complexity.rs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfn build_tree(n: i32) -> Option<Rc<RefCell<TreeNode>>> {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n
    space_complexity.c
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root->left = buildTree(n - 1);\n    root->right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.kt
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n
    space_complexity.rb
    [class]{}-[func]{build_tree}\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) {\n    if (n == 0) return null;\n    const root = try mem_allocator.create(inc.TreeNode(i32));\n    root.init(0);\n    root.left = try buildTree(mem_allocator, n - 1);\n    root.right = try buildTree(mem_allocator, n - 1);\n    return root;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-19 \u00a0 \u6ee1\u4e8c\u53c9\u6811\u4ea7\u751f\u7684\u6307\u6570\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

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

    \u5bf9\u6570\u9636\u5e38\u89c1\u4e8e\u5206\u6cbb\u7b97\u6cd5\u3002\u4f8b\u5982\u5f52\u5e76\u6392\u5e8f\uff0c\u8f93\u5165\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\uff0c\u6bcf\u8f6e\u9012\u5f52\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5904\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\u5c06\u6570\u5b57\u8f6c\u5316\u4e3a\u5b57\u7b26\u4e32\uff0c\u8f93\u5165\u4e00\u4e2a\u6b63\u6574\u6570 \\(n\\) \uff0c\u5b83\u7684\u4f4d\u6570\u4e3a \\(\\lfloor \\log_{10} n \\rfloor + 1\\) \uff0c\u5373\u5bf9\u5e94\u5b57\u7b26\u4e32\u957f\u5ea6\u4e3a \\(\\lfloor \\log_{10} n \\rfloor + 1\\) \uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log_{10} n + 1) = O(\\log n)\\) \u3002

    "},{"location":"chapter_computational_complexity/space_complexity/#244","title":"2.4.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\u975e\u5e38\u56f0\u96be\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\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\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\u975e\u5e38\u91cd\u8981\u3002

    "},{"location":"chapter_computational_complexity/summary/","title":"2.5 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_computational_complexity/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","text":"

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

    • \u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u662f\u8861\u91cf\u7b97\u6cd5\u4f18\u52a3\u7684\u4e24\u4e2a\u4e3b\u8981\u8bc4\u4ef7\u6307\u6807\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\u6d88\u9664\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\u7684\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\u5bf9\u5e94\u51fd\u6570\u6e10\u8fd1\u4e0a\u754c\uff0c\u53cd\u6620\u5f53 \\(n\\) \u8d8b\u5411\u6b63\u65e0\u7a77\u65f6\uff0c\u64cd\u4f5c\u6570\u91cf \\(T(n)\\) \u7684\u589e\u957f\u7ea7\u522b\u3002
    • \u63a8\u7b97\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u4e3a\u4e24\u6b65\uff0c\u9996\u5148\u7edf\u8ba1\u64cd\u4f5c\u6570\u91cf\uff0c\u7136\u540e\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c\u3002
    • \u5e38\u89c1\u65f6\u95f4\u590d\u6742\u5ea6\u4ece\u4f4e\u5230\u9ad8\u6392\u5217\u6709 \\(O(1)\\)\u3001\\(O(\\log n)\\)\u3001\\(O(n)\\)\u3001\\(O(n \\log n)\\)\u3001\\(O(n^2)\\)\u3001\\(O(2^n)\\) \u548c \\(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

    • \u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u4f5c\u7528\u7c7b\u4f3c\u4e8e\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u5360\u7528\u5185\u5b58\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\u7eb3\u5165\u7a7a\u95f4\u590d\u6742\u5ea6\u8ba1\u7b97\u3002\u6682\u5b58\u7a7a\u95f4\u53ef\u5206\u4e3a\u6682\u5b58\u6570\u636e\u3001\u6808\u5e27\u7a7a\u95f4\u548c\u6307\u4ee4\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\u523b\u4e0b\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u3002
    • \u5e38\u89c1\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece\u4f4e\u5230\u9ad8\u6392\u5217\u6709 \\(O(1)\\)\u3001\\(O(\\log n)\\)\u3001\\(O(n)\\)\u3001\\(O(n^2)\\) \u548c \\(O(2^n)\\) \u7b49\u3002
    "},{"location":"chapter_computational_complexity/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u4f18\u5316\u81f3 \\(O(1)\\) \u3002\u4e0d\u8fc7\u7edd\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\uff08\u4f8b\u5982 Java\u3001Python\u3001C++\u3001Go\u3001C# \u7b49\uff09\u4e0d\u652f\u6301\u81ea\u52a8\u4f18\u5316\u5c3e\u9012\u5f52\uff0c\u56e0\u6b64\u901a\u5e38\u8ba4\u4e3a\u7a7a\u95f4\u590d\u6742\u5ea6\u662f \\(O(n)\\) \u3002

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

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

    \u4e0b\u9762\u4ee5\u51e0\u79cd\u5e38\u89c1\u7684\u7f16\u7a0b\u8bed\u8a00\u4e3a\u4f8b\u6765\u8bf4\u660e\u3002

    • C \u8bed\u8a00\u662f\u8fc7\u7a0b\u5f0f\u7f16\u7a0b\u8bed\u8a00\uff0c\u6ca1\u6709\u9762\u5411\u5bf9\u8c61\u7684\u6982\u5ff5\uff0c\u6240\u4ee5\u53ea\u6709\u51fd\u6570\u3002\u4f46\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u521b\u5efa\u7ed3\u6784\u4f53\uff08struct\uff09\u6765\u6a21\u62df\u9762\u5411\u5bf9\u8c61\u7f16\u7a0b\uff0c\u4e0e\u7ed3\u6784\u4f53\u76f8\u5173\u8054\u7684\u51fd\u6570\u5c31\u76f8\u5f53\u4e8e\u5176\u4ed6\u7f16\u7a0b\u8bed\u8a00\u4e2d\u7684\u65b9\u6cd5\u3002
    • Java \u548c C# \u662f\u9762\u5411\u5bf9\u8c61\u7684\u7f16\u7a0b\u8bed\u8a00\uff0c\u4ee3\u7801\u5757\uff08\u65b9\u6cd5\uff09\u901a\u5e38\u4f5c\u4e3a\u67d0\u4e2a\u7c7b\u7684\u4e00\u90e8\u5206\u3002\u9759\u6001\u65b9\u6cd5\u7684\u884c\u4e3a\u7c7b\u4f3c\u4e8e\u51fd\u6570\uff0c\u56e0\u4e3a\u5b83\u88ab\u7ed1\u5b9a\u5728\u7c7b\u4e0a\uff0c\u4e0d\u80fd\u8bbf\u95ee\u7279\u5b9a\u7684\u5b9e\u4f8b\u53d8\u91cf\u3002
    • C++ \u548c Python \u65e2\u652f\u6301\u8fc7\u7a0b\u5f0f\u7f16\u7a0b\uff08\u51fd\u6570\uff09\uff0c\u4e5f\u652f\u6301\u9762\u5411\u5bf9\u8c61\u7f16\u7a0b\uff08\u65b9\u6cd5\uff09\u3002

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

    \u4e0d\u662f\uff0c\u8be5\u56fe\u5c55\u793a\u7684\u662f\u7a7a\u95f4\u590d\u6742\u5ea6\uff0c\u5176\u53cd\u6620\u7684\u662f\u589e\u957f\u8d8b\u52bf\uff0c\u800c\u4e0d\u662f\u5360\u7528\u7a7a\u95f4\u7684\u7edd\u5bf9\u5927\u5c0f\u3002

    \u5047\u8bbe\u53d6 \\(n = 8\\) \uff0c\u4f60\u53ef\u80fd\u4f1a\u53d1\u73b0\u6bcf\u6761\u66f2\u7ebf\u7684\u503c\u4e0e\u51fd\u6570\u5bf9\u5e94\u4e0d\u4e0a\u3002\u8fd9\u662f\u56e0\u4e3a\u6bcf\u6761\u66f2\u7ebf\u90fd\u5305\u542b\u4e00\u4e2a\u5e38\u6570\u9879\uff0c\u7528\u4e8e\u5c06\u53d6\u503c\u8303\u56f4\u538b\u7f29\u5230\u4e00\u4e2a\u89c6\u89c9\u8212\u9002\u7684\u8303\u56f4\u5185\u3002

    \u5728\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\u3002\u4f46\u5bf9\u4e8e \\(n = 8^5\\) \u5c31\u5f88\u597d\u9009\u4e86\uff0c\u8fd9\u65f6\u589e\u957f\u8d8b\u52bf\u5df2\u7ecf\u5360\u4e3b\u5bfc\u4e86\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/","title":"2.3 \u00a0 \u65f6\u95f4\u590d\u6742\u5ea6","text":"

    \u8fd0\u884c\u65f6\u95f4\u53ef\u4ee5\u76f4\u89c2\u4e14\u51c6\u786e\u5730\u53cd\u6620\u7b97\u6cd5\u7684\u6548\u7387\u3002\u5982\u679c\u6211\u4eec\u60f3\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 print() \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\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # \u5faa\u73af n \u6b21\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        cout << 0 << endl;         // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        System.out.println(0);     // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for i := 0; i < n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // \u5faa\u73af n \u6b21\n    for _ in 0 ..< n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // \u5faa\u73af n \u6b21\n    for(let i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        console.log(0); // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // \u5faa\u73af n \u6b21\n    for(let i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        console.log(0); // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // \u5faa\u73af n \u6b21\n  for (int i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n    print(0); // 5 ns\n  }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // \u5faa\u73af n \u6b21\n    for _ in 0..n {     // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {   // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfun algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (i in 0..<n) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        println(0)      // 5 ns\n    }\n}\n
    \n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfn algorithm(n: usize) void {\n    var a: i32 = 2; // 1 ns\n    a += 1; // 1 ns\n    a *= 2; // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (0..n) |_| { // 1 ns\n        std.debug.print(\"{}\\n\", .{0}); // 5 ns\n    }\n}\n

    \u6839\u636e\u4ee5\u4e0a\u65b9\u6cd5\uff0c\u53ef\u4ee5\u5f97\u5230\u7b97\u6cd5\u7684\u8fd0\u884c\u65f6\u95f4\u4e3a \\((6n + 12)\\) ns \uff1a

    \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\]

    \u4f46\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\u5c06\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/#231","title":"2.3.1 \u00a0 \u7edf\u8ba1\u65f6\u95f4\u589e\u957f\u8d8b\u52bf","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\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\u6bd4\u8f83\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\u3001B \u548c C \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\ndef algorithm_A(n: int):\n    print(0)\n# \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\n    cout << 0 << endl;\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        cout << 0 << endl;\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        cout << 0 << endl;\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        System.out.println(0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        System.out.println(0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid AlgorithmB(int n) {\n    for (int i = 0; i < n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid AlgorithmC(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunc algorithm_B(n int) {\n    for i := 0; i < n; i++ {\n        fmt.Println(0)\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithm_C(n int) {\n    for i := 0; i < 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunc algorithmB(n: Int) {\n    for _ in 0 ..< n {\n        print(0)\n    }\n}\n\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithmC(n: Int) {\n    for _ in 0 ..< 1_000_000 {\n        print(0)\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunction algorithm_B(n) {\n    for (let i = 0; i < n; i++) {\n        console.log(0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_C(n) {\n    for (let i = 0; i < 1000000; i++) {\n        console.log(0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i < n; i++) {\n        console.log(0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i < 1000000; i++) {\n        console.log(0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithmA(int n) {\n  print(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithmB(int n) {\n  for (int i = 0; i < n; i++) {\n    print(0);\n  }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithmC(int n) {\n  for (int i = 0; i < 1000000; i++) {\n    print(0);\n  }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfun algorithm_B(n: Int) {\n    for (i in 0..<n){\n        println(0)\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfun algorithm_C(n: Int) {\n    for (i in 0..<1000000) {\n        println(0)\n    }\n}\n
    \n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfn algorithm_A(n: usize) void {\n    _ = n;\n    std.debug.print(\"{}\\n\", .{0});\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfn algorithm_B(n: i32) void {\n    for (0..n) |_| {\n        std.debug.print(\"{}\\n\", .{0});\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfn algorithm_C(n: i32) void {\n    _ = n;\n    for (0..1000000) |_| { \n        std.debug.print(\"{}\\n\", .{0});\n    }\n}\n

    \u56fe 2-7 \u5c55\u793a\u4e86\u4ee5\u4e0a\u4e09\u4e2a\u7b97\u6cd5\u51fd\u6570\u7684\u65f6\u95f4\u590d\u6742\u5ea6\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\u201c\u5e38\u6570\u9636\u201d\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\u201c\u7ebf\u6027\u9636\u201d\u3002
    • \u7b97\u6cd5 C \u4e2d\u7684\u6253\u5370\u64cd\u4f5c\u9700\u8981\u5faa\u73af \\(1000000\\) \u6b21\uff0c\u867d\u7136\u8fd0\u884c\u65f6\u95f4\u5f88\u957f\uff0c\u4f46\u5b83\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\u201c\u5e38\u6570\u9636\u201d\u3002

    \u56fe 2-7 \u00a0 \u7b97\u6cd5 A\u3001B \u548c C \u7684\u65f6\u95f4\u589e\u957f\u8d8b\u52bf

    \u76f8\u8f83\u4e8e\u76f4\u63a5\u7edf\u8ba1\u7b97\u6cd5\u7684\u8fd0\u884c\u65f6\u95f4\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u6709\u54ea\u4e9b\u7279\u70b9\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 \u66f4\u6162\uff0c\u5728 \\(n > 1000000\\) \u65f6\u6bd4\u7b97\u6cd5 C \u66f4\u6162\u3002\u4e8b\u5b9e\u4e0a\uff0c\u53ea\u8981\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u8db3\u591f\u5927\uff0c\u590d\u6742\u5ea6\u4e3a\u201c\u5e38\u6570\u9636\u201d\u7684\u7b97\u6cd5\u4e00\u5b9a\u4f18\u4e8e\u201c\u7ebf\u6027\u9636\u201d\u7684\u7b97\u6cd5\uff0c\u8fd9\u6b63\u662f\u65f6\u95f4\u589e\u957f\u8d8b\u52bf\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\u8fd0\u884c\u65f6\u95f4\u7edf\u8ba1\u201d\u7b80\u5316\u4e3a\u201c\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\u7edf\u8ba1\u201d\uff0c\u8fd9\u6837\u4e00\u6765\u4f30\u7b97\u96be\u5ea6\u5c31\u5927\u5927\u964d\u4f4e\u4e86\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\u7684\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/#232","title":"2.3.2 \u00a0 \u51fd\u6570\u6e10\u8fd1\u4e0a\u754c","text":"

    \u7ed9\u5b9a\u4e00\u4e2a\u8f93\u5165\u5927\u5c0f\u4e3a \\(n\\) \u7684\u51fd\u6570\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # \u5faa\u73af n \u6b21\n    for i in range(n):  # +1\n        print(0)        # +1\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        cout << 0 << endl;    // +1\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        System.out.println(0);    // +1\n    }\n}\n
    void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {   // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        Console.WriteLine(0);   // +1\n    }\n}\n
    func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // \u5faa\u73af n \u6b21\n    for i := 0; i < n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n
    func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // \u5faa\u73af n \u6b21\n    for _ in 0 ..< n { // +1\n        print(0) // +1\n    }\n}\n
    function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // \u5faa\u73af n \u6b21\n    for(let i = 0; i < n; i++){ // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        console.log(0); // +1\n    }\n}\n
    function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // \u5faa\u73af n \u6b21\n    for(let i = 0; i < n; i++){ // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        console.log(0); // +1\n    }\n}\n
    void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // \u5faa\u73af n \u6b21\n  for (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n    print(0); // +1\n  }\n}\n
    fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // \u5faa\u73af n \u6b21\n    for _ in 0..n { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        println!(\"{}\", 0); // +1\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {   // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        printf(\"%d\", 0);            // +1\n    }\n}  \n
    fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // \u5faa\u73af n \u6b21\n    for (i in 0..<n) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        println(0) // +1\n    }\n}\n
    \n
    fn algorithm(n: usize) void {\n    var a: i32 = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // \u5faa\u73af n \u6b21\n    for (0..n) |_| { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        std.debug.print(\"{}\\n\", .{0}); // +1\n    }\n}\n

    \u8bbe\u7b97\u6cd5\u7684\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\u4e0a\u51fd\u6570\u7684\u64cd\u4f5c\u6570\u91cf\u4e3a\uff1a

    \\[ T(n) = 3 + 2n \\]

    \\(T(n)\\) \u662f\u4e00\u6b21\u51fd\u6570\uff0c\u8bf4\u660e\u5176\u8fd0\u884c\u65f6\u95f4\u7684\u589e\u957f\u8d8b\u52bf\u662f\u7ebf\u6027\u7684\uff0c\u56e0\u6b64\u5b83\u7684\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

    \u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u672c\u8d28\u4e0a\u662f\u8ba1\u7b97\u201c\u64cd\u4f5c\u6570\u91cf \\(T(n)\\)\u201d\u7684\u6e10\u8fd1\u4e0a\u754c\uff0c\u5b83\u5177\u6709\u660e\u786e\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)\\) \uff0c\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))\\) \u3002

    \u5982\u56fe 2-8 \u6240\u793a\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

    \u56fe 2-8 \u00a0 \u51fd\u6570\u7684\u6e10\u8fd1\u4e0a\u754c

    "},{"location":"chapter_computational_complexity/time_complexity/#233","title":"2.3.3 \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\u987b\u62c5\u5fc3\u3002\u6211\u4eec\u53ef\u4ee5\u5148\u638c\u63e1\u63a8\u7b97\u65b9\u6cd5\uff0c\u5728\u4e0d\u65ad\u7684\u5b9e\u8df5\u4e2d\uff0c\u5c31\u53ef\u4ee5\u9010\u6e10\u9886\u609f\u5176\u6570\u5b66\u610f\u4e49\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":"1. \u00a0 \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\u5ffd\u7565\u3002\u6839\u636e\u6b64\u539f\u5219\uff0c\u53ef\u4ee5\u603b\u7ed3\u51fa\u4ee5\u4e0b\u8ba1\u6570\u7b80\u5316\u6280\u5de7\u3002

    1. \u5ffd\u7565 \\(T(n)\\) \u4e2d\u7684\u5e38\u6570\u9879\u3002\u56e0\u4e3a\u5b83\u4eec\u90fd\u4e0e \\(n\\) \u65e0\u5173\uff0c\u6240\u4ee5\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\u7b2c 1. \u70b9\u548c\u7b2c 2. \u70b9\u7684\u6280\u5de7\u3002

    \u7ed9\u5b9a\u4e00\u4e2a\u51fd\u6570\uff0c\u6211\u4eec\u53ef\u4ee5\u7528\u4e0a\u8ff0\u6280\u5de7\u6765\u7edf\u8ba1\u64cd\u4f5c\u6570\u91cf\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def algorithm(n: int):\n    a = 1      # +0\uff08\u6280\u5de7 1\uff09\n    a = a + n  # +0\uff08\u6280\u5de7 1\uff09\n    # +n\uff08\u6280\u5de7 2\uff09\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n\uff08\u6280\u5de7 3\uff09\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n
    void algorithm(int n) {\n    int a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (int i = 0; i < 5 * n + 1; i++) {\n        cout << 0 << endl;\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            cout << 0 << endl;\n        }\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (int i = 0; i < 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n
    void Algorithm(int n) {\n    int a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (int i = 0; i < 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n
    func algorithm(n int) {\n    a := 1     // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for i := 0; i < 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for i := 0; i < 2 * n; i++ {\n        for j := 0; j < n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n
    func algorithm(n: Int) {\n    var a = 1 // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for _ in 0 ..< (5 * n + 1) {\n        print(0)\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for _ in 0 ..< (2 * n) {\n        for _ in 0 ..< (n + 1) {\n            print(0)\n        }\n    }\n}\n
    function algorithm(n) {\n    let a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (let i = 0; i < 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (let i = 0; i < 2 * n; i++) {\n        for (let j = 0; j < n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n
    function algorithm(n: number): void {\n    let a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (let i = 0; i < 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (let i = 0; i < 2 * n; i++) {\n        for (let j = 0; j < n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n
    void algorithm(int n) {\n  int a = 1; // +0\uff08\u6280\u5de7 1\uff09\n  a = a + n; // +0\uff08\u6280\u5de7 1\uff09\n  // +n\uff08\u6280\u5de7 2\uff09\n  for (int i = 0; i < 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n\uff08\u6280\u5de7 3\uff09\n  for (int i = 0; i < 2 * n; i++) {\n    for (int j = 0; j < n + 1; j++) {\n      print(0);\n    }\n  }\n}\n
    fn algorithm(n: i32) {\n    let mut a = 1;     // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;        // +0\uff08\u6280\u5de7 1\uff09\n\n    // +n\uff08\u6280\u5de7 2\uff09\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (int i = 0; i < 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n
    fun algorithm(n: Int) {\n    var a = 1   // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n   // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (i in 0..<5 * n + 1) {\n        println(0)\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (i in 0..<2 * n) {\n        for (j in 0..<n + 1) {\n            println(0)\n        }\n    }\n}\n
    \n
    fn algorithm(n: usize) void {\n    var a: i32 = 1;     // +0\uff08\u6280\u5de7 1\uff09\n    a = a + @as(i32, @intCast(n));        // +0\uff08\u6280\u5de7 1\uff09\n\n    // +n\uff08\u6280\u5de7 2\uff09\n    for(0..(5 * n + 1)) |_| {\n        std.debug.print(\"{}\\n\", .{0}); \n    }\n\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for(0..(2 * n)) |_| {\n        for(0..(n + 1)) |_| {\n            std.debug.print(\"{}\\n\", .{0}); \n        }\n    }\n}\n

    \u4ee5\u4e0b\u516c\u5f0f\u5c55\u793a\u4e86\u4f7f\u7528\u4e0a\u8ff0\u6280\u5de7\u524d\u540e\u7684\u7edf\u8ba1\u7ed3\u679c\uff0c\u4e24\u8005\u63a8\u7b97\u51fa\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n^2)\\) \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} \\]"},{"location":"chapter_computational_complexity/time_complexity/#2","title":"2. \u00a0 \u7b2c\u4e8c\u6b65\uff1a\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\u7531 \\(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\u5ffd\u7565\u3002

    \u8868 2-2 \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

    \u8868 2-2 \u00a0 \u4e0d\u540c\u64cd\u4f5c\u6570\u91cf\u5bf9\u5e94\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \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/#234","title":"2.3.4 \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\u5982\u56fe 2-9 \u6240\u793a\uff08\u6309\u7167\u4ece\u4f4e\u5230\u9ad8\u7684\u987a\u5e8f\u6392\u5217\uff09\u3002

    \\[ \\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} \\]

    \u56fe 2-9 \u00a0 \u5e38\u89c1\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7c7b\u578b

    "},{"location":"chapter_computational_complexity/time_complexity/#1-o1","title":"1. \u00a0 \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

    \u5728\u4ee5\u4e0b\u51fd\u6570\u4e2d\uff0c\u5c3d\u7ba1\u64cd\u4f5c\u6570\u91cf size \u53ef\u80fd\u5f88\u5927\uff0c\u4f46\u7531\u4e8e\u5176\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def constant(n: int) -> int:\n    \"\"\"\u5e38\u6570\u9636\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.java
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.cs
    /* \u5e38\u6570\u9636 */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.go
    /* \u5e38\u6570\u9636 */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i < size; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e38\u6570\u9636 */\nfunc constant(n: Int) -> Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..< size {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e38\u6570\u9636 */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i < size; i++) count++;\n    return count;\n}\n
    time_complexity.ts
    /* \u5e38\u6570\u9636 */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i < size; i++) count++;\n    return count;\n}\n
    time_complexity.dart
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i < size; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e38\u6570\u9636 */\nfn constant(n: i32) -> i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i < size; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e38\u6570\u9636 */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 10_0000\n    for (i in 0..<size)\n        count++\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{constant}\n
    time_complexity.zig
    // \u5e38\u6570\u9636\nfn constant(n: i32) i32 {\n    _ = n;\n    var count: i32 = 0;\n    const size: i32 = 100_000;\n    var i: i32 = 0;\n    while(i<size) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_computational_complexity/time_complexity/#2-on","title":"2. \u00a0 \u7ebf\u6027\u9636 \\(O(n)\\)","text":"

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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def linear(n: int) -> int:\n    \"\"\"\u7ebf\u6027\u9636\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636 */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u9636 */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i < n; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636 */\nfunc linear(n: Int) -> Int {\n    var count = 0\n    for _ in 0 ..< n {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636 */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i < n; i++) count++;\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636 */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i < n; i++) count++;\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i < n; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u9636 */\nfn linear(n: i32) -> i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u9636 */\nfun linear(n: Int): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (i in 0..<n)\n        count++\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{linear}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\nfn linear(n: i32) i32 {\n    var count: i32 = 0;\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def array_traversal(nums: list[int]) -> int:\n    \"\"\"\u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\"\"\"\n    count = 0\n    # \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for num in nums:\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(vector<int> &nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for range nums {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums: [Int]) -> Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (let i = 0; i < nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (let i = 0; i < nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(List<int> nums) {\n  int count = 0;\n  // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfn array_traversal(nums: &[i32]) -> i32 {\n    let mut count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{array_traversal}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\nfn arrayTraversal(nums: []i32) i32 {\n    var count: i32 = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (nums) |_| {\n        count += 1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u9700\u6839\u636e\u8f93\u5165\u6570\u636e\u7684\u7c7b\u578b\u6765\u5177\u4f53\u786e\u5b9a\u3002\u6bd4\u5982\u5728\u7b2c\u4e00\u4e2a\u793a\u4f8b\u4e2d\uff0c\u53d8\u91cf \\(n\\) \u4e3a\u8f93\u5165\u6570\u636e\u5927\u5c0f\uff1b\u5728\u7b2c\u4e8c\u4e2a\u793a\u4f8b\u4e2d\uff0c\u6570\u7ec4\u957f\u5ea6 \\(n\\) \u4e3a\u6570\u636e\u5927\u5c0f\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#3-on2","title":"3. \u00a0 \u5e73\u65b9\u9636 \\(O(n^2)\\)","text":"

    \u5e73\u65b9\u9636\u7684\u64cd\u4f5c\u6570\u91cf\u76f8\u5bf9\u4e8e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \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\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n)\\) \uff0c\u56e0\u6b64\u603b\u4f53\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def quadratic(n: int) -> int:\n    \"\"\"\u5e73\u65b9\u9636\"\"\"\n    count = 0\n    # \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636 */\nint Quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n int) int {\n    count := 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for i := 0; i < n; i++ {\n        for j := 0; j < n; j++ {\n            count++\n        }\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n: Int) -> Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for _ in 0 ..< n {\n        for _ in 0 ..< n {\n            count += 1\n        }\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n  int count = 0;\n  // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n  for (int i = 0; i < n; i++) {\n    for (int j = 0; j < n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e73\u65b9\u9636 */\nfn quadratic(n: i32) -> i32 {\n    let mut count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e73\u65b9\u9636 */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (i in 0..<n) {\n        for (j in 0..<n) {\n            count++\n        }\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{quadratic}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) i32 {\n    var count: i32 = 0;\n    var i: i32 = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    while (i < n) : (i += 1) {\n        var j: i32 = 0;\n        while (j < n) : (j += 1) {\n            count += 1;\n        }\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-10 \u5bf9\u6bd4\u4e86\u5e38\u6570\u9636\u3001\u7ebf\u6027\u9636\u548c\u5e73\u65b9\u9636\u4e09\u79cd\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    \u56fe 2-10 \u00a0 \u5e38\u6570\u9636\u3001\u7ebf\u6027\u9636\u548c\u5e73\u65b9\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u4ee5\u5192\u6ce1\u6392\u5e8f\u4e3a\u4f8b\uff0c\u5916\u5c42\u5faa\u73af\u6267\u884c \\(n - 1\\) \u6b21\uff0c\u5185\u5c42\u5faa\u73af\u6267\u884c \\(n-1\\)\u3001\\(n-2\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \u6b21\uff0c\u5e73\u5747\u4e3a \\(n / 2\\) \u6b21\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O((n - 1) n / 2) = O(n^2)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def bubble_sort(nums: list[int]) -> int:\n    \"\"\"\u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\"\"\"\n    count = 0  # \u8ba1\u6570\u5668\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j in range(i):\n            if nums[j] > nums[j + 1]:\n                # \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n    return count\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(vector<int> &nums) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int[] nums) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint BubbleSort(int[] nums) {\n    int count = 0;  // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums []int) int {\n    count := 0 // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j := 0; j < i; j++ {\n            if nums[j] > nums[j+1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums: inout [Int]) -> Int {\n    var count = 0 // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in nums.indices.dropFirst().reversed() {\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\n        for j in 0 ..< i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums) {\n    let count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(List<int> nums) {\n  int count = 0; // \u8ba1\u6570\u5668\n  // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n  for (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\n    for (var j = 0; j < i; j++) {\n      if (nums[j] > nums[j + 1]) {\n        // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n      }\n    }\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfn bubble_sort(nums: &mut [i32]) -> i32 {\n    let mut count = 0; // \u8ba1\u6570\u5668\n\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in (1..nums.len()).rev() {\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\n        for j in 0..i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (i in nums.size - 1 downTo 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\n        for (j in 0..<i) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j] = nums[j + 1].also { nums[j + 1] = nums[j] }\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{bubble_sort}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\nfn bubbleSort(nums: []i32) i32 {\n    var count: i32 = 0;  // \u8ba1\u6570\u5668 \n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    var i: i32 = @as(i32, @intCast(nums.len)) - 1;\n    while (i > 0) : (i -= 1) {\n        var 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\n        while (j < i) : (j += 1) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                var tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_computational_complexity/time_complexity/#4-o2n","title":"4. \u00a0 \u6307\u6570\u9636 \\(O(2^n)\\)","text":"

    \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

    \u56fe 2-11 \u548c\u4ee5\u4e0b\u4ee3\u7801\u6a21\u62df\u4e86\u7ec6\u80de\u5206\u88c2\u7684\u8fc7\u7a0b\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def exponential(n: int) -> int:\n    \"\"\"\u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\n    count = 0\n    base = 1\n    # \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.java
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i < n; i++ {\n        for j := 0; j < base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc exponential(n: Int) -> Int {\n    var count = 0\n    var base = 1\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..< n {\n        for _ in 0 ..< base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i < n; i++) {\n    for (var j = 0; j < base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n
    time_complexity.rs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfn exponential(n: i32) -> i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.kt
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfun exponential(n: Int): Int {\n    var count = 0\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    var base = 1\n    for (i in 0..<n) {\n        for (j in 0..<base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{exponential}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn exponential(n: i32) i32 {\n    var count: i32 = 0;\n    var bas: i32 = 1;\n    var i: i32 = 0;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    while (i < n) : (i += 1) {\n        var j: i32 = 0;\n        while (j < bas) : (j += 1) {\n            count += 1;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-11 \u00a0 \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\u4e2d\u3002\u4f8b\u5982\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u5176\u9012\u5f52\u5730\u4e00\u5206\u4e3a\u4e8c\uff0c\u7ecf\u8fc7 \\(n\\) \u6b21\u5206\u88c2\u540e\u505c\u6b62\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def exp_recur(n: int) -> int:\n    \"\"\"\u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.java
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return 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) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return 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 {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return 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 {\n    if (n === 1) return 1;\n    return 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) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.rs
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn exp_recur(n: i32) -> i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.kt
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n
    time_complexity.rb
    [class]{}-[func]{exp_recur}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn expRecur(n: i32) i32 {\n    if (n == 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6307\u6570\u9636\u589e\u957f\u975e\u5e38\u8fc5\u901f\uff0c\u5728\u7a77\u4e3e\u6cd5\uff08\u66b4\u529b\u641c\u7d22\u3001\u56de\u6eaf\u7b49\uff09\u4e2d\u6bd4\u8f83\u5e38\u89c1\u3002\u5bf9\u4e8e\u6570\u636e\u89c4\u6a21\u8f83\u5927\u7684\u95ee\u9898\uff0c\u6307\u6570\u9636\u662f\u4e0d\u53ef\u63a5\u53d7\u7684\uff0c\u901a\u5e38\u9700\u8981\u4f7f\u7528\u52a8\u6001\u89c4\u5212\u6216\u8d2a\u5fc3\u7b97\u6cd5\u7b49\u6765\u89e3\u51b3\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#5-olog-n","title":"5. \u00a0 \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\u201d\u7684\u60c5\u51b5\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

    \u56fe 2-12 \u548c\u4ee5\u4e0b\u4ee3\u7801\u6a21\u62df\u4e86\u201c\u6bcf\u8f6e\u7f29\u51cf\u5230\u4e00\u534a\u201d\u7684\u8fc7\u7a0b\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log_2 n)\\) \uff0c\u7b80\u8bb0\u4e3a \\(O(\\log n)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def logarithmic(n: int) -> int:\n    \"\"\"\u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\n    count = 0\n    while n > 1:\n        n = n / 2\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc logarithmic(n int) int {\n    count := 0\n    for n > 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc logarithmic(n: Int) -> Int {\n    var count = 0\n    var n = n\n    while n > 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n  int count = 0;\n  while (n > 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfn logarithmic(mut n: i32) -> i32 {\n    let mut count = 0;\n    while n > 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 > 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{logarithmic}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn logarithmic(n: i32) i32 {\n    var count: i32 = 0;\n    var n_var = n;\n    while (n_var > 1)\n    {\n        n_var = n_var / 2;\n        count +=1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-12 \u00a0 \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\u4e2d\u3002\u4ee5\u4e0b\u4ee3\u7801\u5f62\u6210\u4e86\u4e00\u68f5\u9ad8\u5ea6\u4e3a \\(\\log_2 n\\) \u7684\u9012\u5f52\u6811\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def log_recur(n: int) -> int:\n    \"\"\"\u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n <= 1:\n        return 0\n    return log_recur(n / 2) + 1\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint LogRecur(int n) {\n    if (n <= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc logRecur(n int) int {\n    if n <= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc logRecur(n: Int) -> Int {\n    if n <= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n) {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n: number): number {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n  if (n <= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n
    time_complexity.rs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn log_recur(n: i32) -> i32 {\n    if n <= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.kt
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun logRecur(n: Int): Int {\n    if (n <= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n
    time_complexity.rb
    [class]{}-[func]{log_recur}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn logRecur(n: i32) i32 {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5bf9\u6570\u9636\u5e38\u51fa\u73b0\u4e8e\u57fa\u4e8e\u5206\u6cbb\u7b56\u7565\u7684\u7b97\u6cd5\u4e2d\uff0c\u4f53\u73b0\u4e86\u201c\u4e00\u5206\u4e3a\u591a\u201d\u548c\u201c\u5316\u7e41\u4e3a\u7b80\u201d\u7684\u7b97\u6cd5\u601d\u60f3\u3002\u5b83\u589e\u957f\u7f13\u6162\uff0c\u662f\u4ec5\u6b21\u4e8e\u5e38\u6570\u9636\u7684\u7406\u60f3\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    \\(O(\\log n)\\) \u7684\u5e95\u6570\u662f\u591a\u5c11\uff1f

    \u51c6\u786e\u6765\u8bf4\uff0c\u201c\u4e00\u5206\u4e3a \\(m\\)\u201d\u5bf9\u5e94\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(\\log_m n)\\) \u3002\u800c\u901a\u8fc7\u5bf9\u6570\u6362\u5e95\u516c\u5f0f\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u5230\u5177\u6709\u4e0d\u540c\u5e95\u6570\u3001\u76f8\u7b49\u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a

    \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\]

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5e95\u6570 \\(m\\) \u53ef\u4ee5\u5728\u4e0d\u5f71\u54cd\u590d\u6742\u5ea6\u7684\u524d\u63d0\u4e0b\u8f6c\u6362\u3002\u56e0\u6b64\u6211\u4eec\u901a\u5e38\u4f1a\u7701\u7565\u5e95\u6570 \\(m\\) \uff0c\u5c06\u5bf9\u6570\u9636\u76f4\u63a5\u8bb0\u4e3a \\(O(\\log n)\\) \u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#6-on-log-n","title":"6. \u00a0 \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\u76f8\u5173\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def linear_log_recur(n: int) -> int:\n    \"\"\"\u7ebf\u6027\u5bf9\u6570\u9636\"\"\"\n    if n <= 1:\n        return 1\n    count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    for _ in range(n):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint LinearLogRecur(int n) {\n    if (n <= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n int) int {\n    if n <= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i < n; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n: Int) -> Int {\n    if n <= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n) {\n    if (n <= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n: number): number {\n    if (n <= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n  if (n <= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i < n; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfn linear_log_recur(n: i32) -> i32 {\n    if n <= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n as i32 {\n        count += 1;\n    }\n    return count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfun linearLogRecur(n: Int): Int {\n    if (n <= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..<n.toInt()) {\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{linear_log_recur}\n
    time_complexity.zig
    // \u7ebf\u6027\u5bf9\u6570\u9636\nfn linearLogRecur(n: i32) i32 {\n    if (n <= 1) return 1;\n    var count: i32 = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-13 \u5c55\u793a\u4e86\u7ebf\u6027\u5bf9\u6570\u9636\u7684\u751f\u6210\u65b9\u5f0f\u3002\u4e8c\u53c9\u6811\u7684\u6bcf\u4e00\u5c42\u7684\u64cd\u4f5c\u603b\u6570\u90fd\u4e3a \\(n\\) \uff0c\u6811\u5171\u6709 \\(\\log_2 n + 1\\) \u5c42\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    \u56fe 2-13 \u00a0 \u7ebf\u6027\u5bf9\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \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

    "},{"location":"chapter_computational_complexity/time_complexity/#7-on","title":"7. \u00a0 \u9636\u4e58\u9636 \\(O(n!)\\)","text":"

    \u9636\u4e58\u9636\u5bf9\u5e94\u6570\u5b66\u4e0a\u7684\u201c\u5168\u6392\u5217\u201d\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 \\dots \\times 2 \\times 1 \\]

    \u9636\u4e58\u901a\u5e38\u4f7f\u7528\u9012\u5f52\u5b9e\u73b0\u3002\u5982\u56fe 2-14 \u548c\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\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\u505c\u6b62\u5206\u88c2\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def factorial_recur(n: int) -> int:\n    \"\"\"\u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n
    time_complexity.cpp
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for i := 0; i < n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n: Int) -> Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in 0 ..< n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n
    time_complexity.js
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (let i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (let i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n  for (var i = 0; i < n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn factorial_recur(n: i32) -> i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n
    time_complexity.c
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (i in 0..<n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{factorial_recur}\n
    time_complexity.zig
    // \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn factorialRecur(n: i32) i32 {\n    if (n == 0) return 1;\n    var count: i32 = 0;\n    var i: i32 = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    while (i < n) : (i += 1) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-14 \u00a0 \u9636\u4e58\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u8bf7\u6ce8\u610f\uff0c\u56e0\u4e3a\u5f53 \\(n \\geq 4\\) \u65f6\u6052\u6709 \\(n! > 2^n\\) \uff0c\u6240\u4ee5\u9636\u4e58\u9636\u6bd4\u6307\u6570\u9636\u589e\u957f\u5f97\u66f4\u5feb\uff0c\u5728 \\(n\\) \u8f83\u5927\u65f6\u4e5f\u662f\u4e0d\u53ef\u63a5\u53d7\u7684\u3002

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

    \u7b97\u6cd5\u7684\u65f6\u95f4\u6548\u7387\u5f80\u5f80\u4e0d\u662f\u56fa\u5b9a\u7684\uff0c\u800c\u662f\u4e0e\u8f93\u5165\u6570\u636e\u7684\u5206\u5e03\u6709\u5173\u3002\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\u6bcf\u4e2a\u6570\u5b57\u53ea\u51fa\u73b0\u4e00\u6b21\uff1b\u4f46\u5143\u7d20\u987a\u5e8f\u662f\u968f\u673a\u6253\u4e71\u7684\uff0c\u4efb\u52a1\u76ee\u6807\u662f\u8fd4\u56de\u5143\u7d20 \\(1\\) \u7684\u7d22\u5f15\u3002\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u4ee5\u4e0b\u7ed3\u8bba\u3002

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

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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    nums = [i for i in range(1, n + 1)]\n    # \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -> int:\n    \"\"\"\u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\"\"\"\n    for 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)\n        if nums[i] == 1:\n            return i\n    return -1\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) {\n    vector<int> nums(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u4f7f\u7528\u7cfb\u7edf\u65f6\u95f4\u751f\u6210\u968f\u673a\u79cd\u5b50\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(vector<int> &nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n
    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) {\n    Integer[] nums = new Integer[n];\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -> int[]\n    int[] res = new int[n];\n    for (int i = 0; i < n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int[] nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -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) {\n    int[] nums = new int[n];\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (int i = 0; i < nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint FindOne(int[] nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\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 {\n    nums := make([]int, n)\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for i := 0; i < n; i++ {\n        nums[i] = i + 1\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums []int) int {\n    for 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)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -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 }\n    var nums = Array(1 ... n)\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    nums.shuffle()\n    return nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums: [Int]) -> Int {\n    for 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)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -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) {\n    const nums = Array(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (let i = 0; i < n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums) {\n    for (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)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -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[] {\n    const nums = Array(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (let i = 0; i < n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums: number[]): number {\n    for (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)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -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) {\n  final nums = List.filled(n, 0);\n  // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i < n; i++) {\n    nums[i] = i + 1;\n  }\n  // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n  nums.shuffle();\n\n  return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(List<int> nums) {\n  for (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)\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n
    worst_best_time_complexity.rs
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfn random_numbers(n: i32) -> Vec<i32> {\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::<Vec<i32>>();\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    nums.shuffle(&mut thread_rng());\n    nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfn find_one(nums: &[i32]) -> Option<usize> {\n    for i in 0..nums.len() {\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)\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\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\u4e3a n \uff0c\u5143\u7d20\u7c7b\u578b\u4e3a int \uff09\n    int *nums = (int *)malloc(n * sizeof(int));\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (int i = n - 1; i > 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int *nums, int n) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n
    worst_best_time_complexity.kt
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfun randomNumbers(n: Int): Array<Int?> {\n    val nums = IntArray(n)\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (i in 0..<n) {\n        nums[i] = i + 1\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    val mutableList = nums.toMutableList()\n    mutableList.shuffle()\n    // Integer[] -> int[]\n    val res = arrayOfNulls<Int>(n)\n    for (i in 0..<n) {\n        res[i] = mutableList[i]\n    }\n    return res\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfun findOne(nums: Array<Int?>): Int {\n    for (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)\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n
    worst_best_time_complexity.rb
    [class]{}-[func]{random_numbers}\n\n[class]{}-[func]{find_one}\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\nfn randomNumbers(comptime n: usize) [n]i32 {\n    var nums: [n]i32 = undefined;\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (&nums, 0..) |*num, i| {\n        num.* = @as(i32, @intCast(i)) + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    const rand = std.crypto.random;\n    rand.shuffle(i32, &nums);\n    return nums;\n}\n\n// \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\nfn findOne(nums: []i32) i32 {\n    for (nums, 0..) |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)\n        if (num == 1) return @intCast(i);\n    }\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u6211\u4eec\u5728\u5b9e\u9645\u4e2d\u5f88\u5c11\u4f7f\u7528\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\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\u800c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u66f4\u4e3a\u5b9e\u7528\uff0c\u56e0\u4e3a\u5b83\u7ed9\u51fa\u4e86\u4e00\u4e2a\u6548\u7387\u5b89\u5168\u503c\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\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u53ea\u51fa\u73b0\u4e8e\u201c\u7279\u6b8a\u7684\u6570\u636e\u5206\u5e03\u201d\uff0c\u8fd9\u4e9b\u60c5\u51b5\u7684\u51fa\u73b0\u6982\u7387\u53ef\u80fd\u5f88\u5c0f\uff0c\u5e76\u4e0d\u80fd\u771f\u5b9e\u5730\u53cd\u6620\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u3002\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\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\u5c31\u662f\u6570\u7ec4\u957f\u5ea6\u7684\u4e00\u534a \\(n / 2\\) \uff0c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(\\Theta(n / 2) = \\Theta(n)\\) \u3002

    \u4f46\u5bf9\u4e8e\u8f83\u4e3a\u590d\u6742\u7684\u7b97\u6cd5\uff0c\u8ba1\u7b97\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u5f80\u5f80\u6bd4\u8f83\u56f0\u96be\uff0c\u56e0\u4e3a\u5f88\u96be\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\u56e0\u6b64\u6211\u4eec\u5e38\u5e38\u4f7f\u7528\u5b83\u6765\u8868\u793a\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u3002\u4f46\u4ece\u4e25\u683c\u610f\u4e49\u4e0a\u8bb2\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":"\u7b2c 3 \u7ae0 \u00a0 \u6570\u636e\u7ed3\u6784","text":"

    Abstract

    \u6570\u636e\u7ed3\u6784\u5982\u540c\u4e00\u526f\u7a33\u56fa\u800c\u591a\u6837\u7684\u6846\u67b6\u3002

    \u5b83\u4e3a\u6570\u636e\u7684\u6709\u5e8f\u7ec4\u7ec7\u63d0\u4f9b\u4e86\u84dd\u56fe\uff0c\u7b97\u6cd5\u5f97\u4ee5\u5728\u6b64\u57fa\u7840\u4e0a\u751f\u52a8\u8d77\u6765\u3002

    "},{"location":"chapter_data_structure/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 3.1 \u00a0 \u6570\u636e\u7ed3\u6784\u5206\u7c7b
    • 3.2 \u00a0 \u57fa\u672c\u6570\u636e\u7c7b\u578b
    • 3.3 \u00a0 \u6570\u5b57\u7f16\u7801 *
    • 3.4 \u00a0 \u5b57\u7b26\u7f16\u7801 *
    • 3.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_data_structure/basic_data_types/","title":"3.2 \u00a0 \u57fa\u672c\u6570\u636e\u7c7b\u578b","text":"

    \u5f53\u8c08\u53ca\u8ba1\u7b97\u673a\u4e2d\u7684\u6570\u636e\u65f6\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\uff0c\u4e3b\u8981\u5305\u62ec\u4ee5\u4e0b\u51e0\u79cd\u3002

    • \u6574\u6570\u7c7b\u578b byte\u3001short\u3001int\u3001long \u3002
    • \u6d6e\u70b9\u6570\u7c7b\u578b float\u3001double \uff0c\u7528\u4e8e\u8868\u793a\u5c0f\u6570\u3002
    • \u5b57\u7b26\u7c7b\u578b char \uff0c\u7528\u4e8e\u8868\u793a\u5404\u79cd\u8bed\u8a00\u7684\u5b57\u6bcd\u3001\u6807\u70b9\u7b26\u53f7\u751a\u81f3\u8868\u60c5\u7b26\u53f7\u7b49\u3002
    • \u5e03\u5c14\u7c7b\u578b bool \uff0c\u7528\u4e8e\u8868\u793a\u201c\u662f\u201d\u4e0e\u201c\u5426\u201d\u5224\u65ad\u3002

    \u57fa\u672c\u6570\u636e\u7c7b\u578b\u4ee5\u4e8c\u8fdb\u5236\u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u4e2d\u3002\u4e00\u4e2a\u4e8c\u8fdb\u5236\u4f4d\u5373\u4e3a \\(1\\) \u6bd4\u7279\u3002\u5728\u7edd\u5927\u591a\u6570\u73b0\u4ee3\u64cd\u4f5c\u7cfb\u7edf\u4e2d\uff0c\\(1\\) \u5b57\u8282\uff08byte\uff09\u7531 \\(8\\) \u6bd4\u7279\uff08bit\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\u3002\u4e0b\u9762\u4ee5 Java \u4e3a\u4f8b\u3002

    • \u6574\u6570\u7c7b\u578b byte \u5360\u7528 \\(1\\) \u5b57\u8282 = \\(8\\) \u6bd4\u7279 \uff0c\u53ef\u4ee5\u8868\u793a \\(2^{8}\\) \u4e2a\u6570\u5b57\u3002
    • \u6574\u6570\u7c7b\u578b int \u5360\u7528 \\(4\\) \u5b57\u8282 = \\(32\\) \u6bd4\u7279 \uff0c\u53ef\u4ee5\u8868\u793a \\(2^{32}\\) \u4e2a\u6570\u5b57\u3002

    \u8868 3-1 \u5217\u4e3e\u4e86 Java \u4e2d\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\u987b\u6b7b\u8bb0\u786c\u80cc\uff0c\u5927\u81f4\u7406\u89e3\u5373\u53ef\uff0c\u9700\u8981\u65f6\u53ef\u4ee5\u901a\u8fc7\u67e5\u8868\u6765\u56de\u5fc6\u3002

    \u8868 3-1 \u00a0 \u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u5360\u7528\u7a7a\u95f4\u548c\u53d6\u503c\u8303\u56f4

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

    \u8bf7\u6ce8\u610f\uff0c\u8868 3-1 \u9488\u5bf9\u7684\u662f Java \u7684\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u60c5\u51b5\u3002\u6bcf\u79cd\u7f16\u7a0b\u8bed\u8a00\u90fd\u6709\u5404\u81ea\u7684\u6570\u636e\u7c7b\u578b\u5b9a\u4e49\uff0c\u5b83\u4eec\u7684\u5360\u7528\u7a7a\u95f4\u3001\u53d6\u503c\u8303\u56f4\u548c\u9ed8\u8ba4\u503c\u53ef\u80fd\u4f1a\u6709\u6240\u4e0d\u540c\u3002

    • \u5728 Python \u4e2d\uff0c\u6574\u6570\u7c7b\u578b int \u53ef\u4ee5\u662f\u4efb\u610f\u5927\u5c0f\uff0c\u53ea\u53d7\u9650\u4e8e\u53ef\u7528\u5185\u5b58\uff1b\u6d6e\u70b9\u6570 float \u662f\u53cc\u7cbe\u5ea6 64 \u4f4d\uff1b\u6ca1\u6709 char \u7c7b\u578b\uff0c\u5355\u4e2a\u5b57\u7b26\u5b9e\u9645\u4e0a\u662f\u957f\u5ea6\u4e3a 1 \u7684\u5b57\u7b26\u4e32 str \u3002
    • C \u548c C++ \u672a\u660e\u786e\u89c4\u5b9a\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u5927\u5c0f\uff0c\u800c\u56e0\u5b9e\u73b0\u548c\u5e73\u53f0\u5404\u5f02\u3002\u8868 3-1 \u9075\u5faa LP64 \u6570\u636e\u6a21\u578b\uff0c\u5176\u7528\u4e8e\u5305\u62ec Linux \u548c macOS \u5728\u5185\u7684 Unix 64 \u4f4d\u64cd\u4f5c\u7cfb\u7edf\u3002
    • \u5b57\u7b26 char \u7684\u5927\u5c0f\u5728 C \u548c C++ \u4e2d\u4e3a 1 \u5b57\u8282\uff0c\u5728\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4e2d\u53d6\u51b3\u4e8e\u7279\u5b9a\u7684\u5b57\u7b26\u7f16\u7801\u65b9\u6cd5\uff0c\u8be6\u89c1\u201c\u5b57\u7b26\u7f16\u7801\u201d\u7ae0\u8282\u3002
    • \u5373\u4f7f\u8868\u793a\u5e03\u5c14\u91cf\u4ec5\u9700 1 \u4f4d\uff08\\(0\\) \u6216 \\(1\\)\uff09\uff0c\u5b83\u5728\u5185\u5b58\u4e2d\u901a\u5e38\u4e5f\u5b58\u50a8\u4e3a 1 \u5b57\u8282\u3002\u8fd9\u662f\u56e0\u4e3a\u73b0\u4ee3\u8ba1\u7b97\u673a CPU \u901a\u5e38\u5c06 1 \u5b57\u8282\u4f5c\u4e3a\u6700\u5c0f\u5bfb\u5740\u5185\u5b58\u5355\u5143\u3002

    \u90a3\u4e48\uff0c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u4e0e\u6570\u636e\u7ed3\u6784\u4e4b\u95f4\u6709\u4ec0\u4e48\u8054\u7cfb\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\u8fd9\u53e5\u8bdd\u7684\u4e3b\u8bed\u662f\u201c\u7ed3\u6784\u201d\u800c\u975e\u201c\u6570\u636e\u201d\u3002

    \u5982\u679c\u60f3\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 \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\u4f8b\u5982\u4ee5\u4e0b\u4ee3\u7801\uff0c\u6211\u4eec\u7528\u76f8\u540c\u7684\u6570\u636e\u7ed3\u6784\uff08\u6570\u7ec4\uff09\u6765\u5b58\u50a8\u4e0e\u8868\u793a\u4e0d\u540c\u7684\u57fa\u672c\u6570\u636e\u7c7b\u578b\uff0c\u5305\u62ec int\u3001float\u3001char\u3001bool \u7b49\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# Python \u7684\u5b57\u7b26\u5b9e\u9645\u4e0a\u662f\u957f\u5ea6\u4e3a 1 \u7684\u5b57\u7b26\u4e32\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python \u7684\u5217\u8868\u53ef\u4ee5\u81ea\u7531\u5b58\u50a8\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u548c\u5bf9\u8c61\u5f15\u7528\ndata = [0, 0.0, 'a', False, ListNode(0)]\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 bools[5];\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];\nboolean[] bools = new boolean[5];\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[] bools = new bool[5];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\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 bools: boolean[] = [];\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> bools = List.filled(5, false);\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nlet numbers: Vec<i32> = vec![0; 5];\nlet decimals: Vec<f32> = vec![0.0; 5];\nlet characters: Vec<char> = vec!['0'; 5];\nlet bools: Vec<bool> = vec![false; 5];\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 bools[10];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n
    \n
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u201c\u5b57\u7b26\u96c6\u201d\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\u5176\u5168\u79f0\u4e3a American Standard Code for Information Interchange\uff08\u7f8e\u56fd\u6807\u51c6\u4fe1\u606f\u4ea4\u6362\u4ee3\u7801\uff09\u3002\u5b83\u4f7f\u7528 7 \u4f4d\u4e8c\u8fdb\u5236\u6570\uff08\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\u5982\u56fe 3-6 \u6240\u793a\uff0cASCII \u7801\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

    \u56fe 3-6 \u00a0 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\u300cEASCII\u300d\u5b57\u7b26\u96c6\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\u6bd4\u5982\u6c49\u5b57\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\u7f55\u89c1\u5b57\u548c\u7e41\u4f53\u5b57\u3002\u300cGBK\u300d\u5b57\u7b26\u96c6\u662f\u5728 GB2312 \u7684\u57fa\u7840\u4e0a\u6269\u5c55\u5f97\u5230\u7684\uff0c\u5b83\u5171\u6536\u5f55\u4e86 21886 \u4e2a\u6c49\u5b57\u3002\u5728 GBK \u7684\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\u6280\u672f\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\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u540c\u4e00\u79cd\u8bed\u8a00\u5b58\u5728\u591a\u79cd\u5b57\u7b26\u96c6\u6807\u51c6\uff0c\u5982\u679c\u4e24\u53f0\u8ba1\u7b97\u673a\u4f7f\u7528\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\u7814\u7a76\u4eba\u5458\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\u4e2d\u6587\u540d\u79f0\u4e3a\u201c\u7edf\u4e00\u7801\u201d\uff0c\u7406\u8bba\u4e0a\u80fd\u5bb9\u7eb3 100 \u591a\u4e07\u4e2a\u5b57\u7b26\u3002\u5b83\u81f4\u529b\u4e8e\u5c06\u5168\u7403\u8303\u56f4\u5185\u7684\u5b57\u7b26\u7eb3\u5165\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\u81f3 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\u751a\u81f3\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\u7528 3 \u5b57\u8282\u751a\u81f3 4 \u5b57\u8282\u3002

    Unicode \u662f\u4e00\u79cd\u901a\u7528\u5b57\u7b26\u96c6\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\u4e00\u4e2a\u6587\u672c\u4e2d\u65f6\uff0c\u7cfb\u7edf\u5982\u4f55\u89e3\u6790\u5b57\u7b26\uff1f\u4f8b\u5982\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\u56fe 3-7 \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 \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\u8fd9\u4e2a\u77ed\u8bed\u7684\u5185\u5bb9\u4e86\u3002

    \u56fe 3-7 \u00a0 Unicode \u7f16\u7801\u793a\u4f8b

    \u7136\u800c ASCII \u7801\u5df2\u7ecf\u5411\u6211\u4eec\u8bc1\u660e\uff0c\u7f16\u7801\u82f1\u6587\u53ea\u9700 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\u7684\u4e24\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\u5ea6\u7684\u7f16\u7801\uff0c\u4f7f\u7528 1 \u5230 4 \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 1 \u5b57\u8282\uff0c\u62c9\u4e01\u5b57\u6bcd\u548c\u5e0c\u814a\u5b57\u6bcd\u9700\u8981 2 \u5b57\u8282\uff0c\u5e38\u7528\u7684\u4e2d\u6587\u5b57\u7b26\u9700\u8981 3 \u5b57\u8282\uff0c\u5176\u4ed6\u7684\u4e00\u4e9b\u751f\u50fb\u5b57\u7b26\u9700\u8981 4 \u5b57\u8282\u3002

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

    • \u5bf9\u4e8e\u957f\u5ea6\u4e3a 1 \u5b57\u8282\u7684\u5b57\u7b26\uff0c\u5c06\u6700\u9ad8\u4f4d\u8bbe\u7f6e\u4e3a \\(0\\) \uff0c\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\\) \uff0c\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

    \u56fe 3-8 \u5c55\u793a\u4e86\u201cHello\u7b97\u6cd5\u201d\u5bf9\u5e94\u7684 UTF-8 \u7f16\u7801\u3002\u89c2\u5bdf\u53d1\u73b0\uff0c\u7531\u4e8e\u6700\u9ad8 \\(n\\) \u4f4d\u90fd\u8bbe\u7f6e\u4e3a \\(1\\) \uff0c\u56e0\u6b64\u7cfb\u7edf\u53ef\u4ee5\u901a\u8fc7\u8bfb\u53d6\u6700\u9ad8\u4f4d \\(1\\) \u7684\u4e2a\u6570\u6765\u89e3\u6790\u51fa\u5b57\u7b26\u7684\u957f\u5ea6\u4e3a \\(n\\) \u3002

    \u4f46\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\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\u5224\u65ad\u51fa\u5f02\u5e38\u3002

    \u4e4b\u6240\u4ee5\u5c06 \\(10\\) \u5f53\u4f5c\u6821\u9a8c\u7b26\uff0c\u662f\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\u4e2a\u7ed3\u8bba\u53ef\u4ee5\u7528\u53cd\u8bc1\u6cd5\u6765\u8bc1\u660e\uff1a\u5047\u8bbe\u4e00\u4e2a\u5b57\u7b26\u7684\u6700\u9ad8\u4e24\u4f4d\u662f \\(10\\) \uff0c\u8bf4\u660e\u8be5\u5b57\u7b26\u7684\u957f\u5ea6\u4e3a \\(1\\) \uff0c\u5bf9\u5e94 ASCII \u7801\u3002\u800c ASCII \u7801\u7684\u6700\u9ad8\u4f4d\u5e94\u8be5\u662f \\(0\\) \uff0c\u4e0e\u5047\u8bbe\u77db\u76fe\u3002

    \u56fe 3-8 \u00a0 UTF-8 \u7f16\u7801\u793a\u4f8b

    \u9664\u4e86 UTF-8 \u4e4b\u5916\uff0c\u5e38\u89c1\u7684\u7f16\u7801\u65b9\u5f0f\u8fd8\u5305\u62ec\u4ee5\u4e0b\u4e24\u79cd\u3002

    • UTF-16 \u7f16\u7801\uff1a\u4f7f\u7528 2 \u6216 4 \u5b57\u8282\u6765\u8868\u793a\u4e00\u4e2a\u5b57\u7b26\u3002\u6240\u6709\u7684 ASCII \u5b57\u7b26\u548c\u5e38\u7528\u7684\u975e\u82f1\u6587\u5b57\u7b26\uff0c\u90fd\u7528 2 \u5b57\u8282\u8868\u793a\uff1b\u5c11\u6570\u5b57\u7b26\u9700\u8981\u7528\u5230 4 \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 \u5b57\u8282\u3002\u8fd9\u610f\u5473\u7740 UTF-32 \u6bd4 UTF-8 \u548c UTF-16 \u66f4\u5360\u7528\u7a7a\u95f4\uff0c\u7279\u522b\u662f\u5bf9\u4e8e ASCII \u5b57\u7b26\u5360\u6bd4\u8f83\u9ad8\u7684\u6587\u672c\u3002

    \u4ece\u5b58\u50a8\u7a7a\u95f4\u5360\u7528\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 \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\u4ec5\u9700 2 \u5b57\u8282\uff0c\u800c UTF-8 \u53ef\u80fd\u9700\u8981 3 \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\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\u7f16\u7801\u3002\u5728\u7b49\u957f\u7f16\u7801\u4e0b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5b57\u7b26\u4e32\u770b\u4f5c\u6570\u7ec4\u6765\u5904\u7406\uff0c\u8fd9\u79cd\u505a\u6cd5\u5177\u6709\u4ee5\u4e0b\u4f18\u70b9\u3002

    • \u968f\u673a\u8bbf\u95ee\uff1aUTF-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\u60f3\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\uff1a\u4e0e\u968f\u673a\u8bbf\u95ee\u7c7b\u4f3c\uff0c\u8ba1\u7b97 UTF-16 \u7f16\u7801\u7684\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\uff1a\u5728 UTF-16 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u4e0a\uff0c\u5f88\u591a\u5b57\u7b26\u4e32\u64cd\u4f5c\uff08\u5982\u5206\u5272\u3001\u8fde\u63a5\u3001\u63d2\u5165\u3001\u5220\u9664\u7b49\uff09\u66f4\u5bb9\u6613\u8fdb\u884c\u3002\u5728 UTF-8 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u4e0a\uff0c\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

    \u5b9e\u9645\u4e0a\uff0c\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\u8bb8\u591a\u56e0\u7d20\u3002

    • 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 1995 \u5e74 Netscape \u516c\u53f8\u9996\u6b21\u63a8\u51fa JavaScript \u8bed\u8a00\u65f6\uff0cUnicode \u8fd8\u5904\u4e8e\u53d1\u5c55\u65e9\u671f\uff0c\u90a3\u65f6\u5019\u4f7f\u7528 16 \u4f4d\u7684\u7f16\u7801\u5c31\u8db3\u4ee5\u8868\u793a\u6240\u6709\u7684 Unicode \u5b57\u7b26\u4e86\u3002
    • C# \u4f7f\u7528 UTF-16 \u7f16\u7801\uff0c\u4e3b\u8981\u662f\u56e0\u4e3a .NET \u5e73\u53f0\u662f\u7531 Microsoft \u8bbe\u8ba1\u7684\uff0c\u800c Microsoft \u7684\u5f88\u591a\u6280\u672f\uff08\u5305\u62ec Windows \u64cd\u4f5c\u7cfb\u7edf\uff09\u90fd\u5e7f\u6cdb\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\u4ece\u800c\u4e27\u5931\u4e86\u7b49\u957f\u7f16\u7801\u7684\u4f18\u52bf\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u5904\u7406\u4ee3\u7406\u5bf9\u9700\u8981\u989d\u5916\u589e\u52a0\u4ee3\u7801\uff0c\u8fd9\u63d0\u9ad8\u4e86\u7f16\u7a0b\u7684\u590d\u6742\u6027\u548c\u8c03\u8bd5\u96be\u5ea6\u3002

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

    • Python \u4e2d\u7684 str \u4f7f\u7528 Unicode \u7f16\u7801\uff0c\u5e76\u91c7\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\u82e5\u5b57\u7b26\u4e32\u4e2d\u5168\u90e8\u662f ASCII \u5b57\u7b26\uff0c\u5219\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 1 \u5b57\u8282\uff1b\u5982\u679c\u6709\u5b57\u7b26\u8d85\u51fa\u4e86 ASCII \u8303\u56f4\uff0c\u4f46\u5168\u90e8\u5728\u57fa\u672c\u591a\u8bed\u8a00\u5e73\u9762\uff08BMP\uff09\u5185\uff0c\u5219\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 2 \u5b57\u8282\uff1b\u5982\u679c\u6709\u8d85\u51fa BMP \u7684\u5b57\u7b26\uff0c\u5219\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 4 \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\u4e0d\u540c\u7684\u95ee\u9898\u3002\u5728\u6587\u4ef6\u5b58\u50a8\u6216\u7f51\u7edc\u4f20\u8f93\u4e2d\uff0c\u6211\u4eec\u901a\u5e38\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":"

    \u5e38\u89c1\u7684\u6570\u636e\u7ed3\u6784\u5305\u62ec\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\uff0c\u5b83\u4eec\u53ef\u4ee5\u4ece\u201c\u903b\u8f91\u7ed3\u6784\u201d\u548c\u201c\u7269\u7406\u7ed3\u6784\u201d\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":"

    \u903b\u8f91\u7ed3\u6784\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\u4e00\u5b9a\u987a\u5e8f\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\u201c\u7956\u5148\u201d\u4e0e\u201c\u540e\u4ee3\u201d\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

    \u5982\u56fe 3-1 \u6240\u793a\uff0c\u903b\u8f91\u7ed3\u6784\u53ef\u5206\u4e3a\u201c\u7ebf\u6027\u201d\u548c\u201c\u975e\u7ebf\u6027\u201d\u4e24\u5927\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\uff0c\u5143\u7d20\u4e4b\u95f4\u662f\u4e00\u5bf9\u4e00\u7684\u987a\u5e8f\u5173\u7cfb\u3002
    • \u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff1a\u6811\u3001\u5806\u3001\u56fe\u3001\u54c8\u5e0c\u8868\u3002

    \u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u8fdb\u4e00\u6b65\u5212\u5206\u4e3a\u6811\u5f62\u7ed3\u6784\u548c\u7f51\u72b6\u7ed3\u6784\u3002

    • \u6811\u5f62\u7ed3\u6784\uff1a\u6811\u3001\u5806\u3001\u54c8\u5e0c\u8868\uff0c\u5143\u7d20\u4e4b\u95f4\u662f\u4e00\u5bf9\u591a\u7684\u5173\u7cfb\u3002
    • \u7f51\u72b6\u7ed3\u6784\uff1a\u56fe\uff0c\u5143\u7d20\u4e4b\u95f4\u662f\u591a\u5bf9\u591a\u7684\u5173\u7cfb\u3002

    \u56fe 3-1 \u00a0 \u7ebf\u6027\u6570\u636e\u7ed3\u6784\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\u5206\u6563","text":"

    \u5f53\u7b97\u6cd5\u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u6b63\u5728\u5904\u7406\u7684\u6570\u636e\u4e3b\u8981\u5b58\u50a8\u5728\u5185\u5b58\u4e2d\u3002\u56fe 3-2 \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\u4e00\u5b9a\u5927\u5c0f\u7684\u6570\u636e\u3002

    \u7cfb\u7edf\u901a\u8fc7\u5185\u5b58\u5730\u5740\u6765\u8bbf\u95ee\u76ee\u6807\u4f4d\u7f6e\u7684\u6570\u636e\u3002\u5982\u56fe 3-2 \u6240\u793a\uff0c\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

    \u56fe 3-2 \u00a0 \u5185\u5b58\u6761\u3001\u5185\u5b58\u7a7a\u95f4\u3001\u5185\u5b58\u5730\u5740

    Tip

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u5c06\u5185\u5b58\u6bd4\u4f5c Excel \u8868\u683c\u662f\u4e00\u4e2a\u7b80\u5316\u7684\u7c7b\u6bd4\uff0c\u5b9e\u9645\u5185\u5b58\u7684\u5de5\u4f5c\u673a\u5236\u6bd4\u8f83\u590d\u6742\uff0c\u6d89\u53ca\u5730\u5740\u7a7a\u95f4\u3001\u5185\u5b58\u7ba1\u7406\u3001\u7f13\u5b58\u673a\u5236\u3001\u865a\u62df\u5185\u5b58\u548c\u7269\u7406\u5185\u5b58\u7b49\u6982\u5ff5\u3002

    \u5185\u5b58\u662f\u6240\u6709\u7a0b\u5e8f\u7684\u5171\u4eab\u8d44\u6e90\uff0c\u5f53\u67d0\u5757\u5185\u5b58\u88ab\u67d0\u4e2a\u7a0b\u5e8f\u5360\u7528\u65f6\uff0c\u5219\u65e0\u6cd5\u88ab\u5176\u4ed6\u7a0b\u5e8f\u540c\u65f6\u4f7f\u7528\u4e86\u3002\u56e0\u6b64\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\u6bd4\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\u7f3a\u5c11\u8fde\u7eed\u5927\u5757\u7684\u5185\u5b58\u7a7a\u95f4\uff0c\u90a3\u4e48\u6240\u9009\u7528\u7684\u6570\u636e\u7ed3\u6784\u5fc5\u987b\u80fd\u591f\u5b58\u50a8\u5728\u5206\u6563\u7684\u5185\u5b58\u7a7a\u95f4\u5185\u3002

    \u5982\u56fe 3-3 \u6240\u793a\uff0c\u7269\u7406\u7ed3\u6784\u53cd\u6620\u4e86\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u5b58\u50a8\u65b9\u5f0f\uff0c\u53ef\u5206\u4e3a\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\uff08\u6570\u7ec4\uff09\u548c\u5206\u6563\u7a7a\u95f4\u5b58\u50a8\uff08\u94fe\u8868\uff09\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\u4e24\u79cd\u7269\u7406\u7ed3\u6784\u5728\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u65b9\u9762\u5448\u73b0\u51fa\u4e92\u8865\u7684\u7279\u70b9\u3002

    \u56fe 3-3 \u00a0 \u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u4e0e\u5206\u6563\u7a7a\u95f4\u5b58\u50a8

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\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\u3002
    • \u57fa\u4e8e\u94fe\u8868\u53ef\u5b9e\u73b0\uff1a\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u7b49\u3002

    \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u4e5f\u79f0\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\u4e5f\u79f0\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\u679c\u4f60\u611f\u89c9\u7269\u7406\u7ed3\u6784\u7406\u89e3\u8d77\u6765\u6709\u56f0\u96be\uff0c\u5efa\u8bae\u5148\u9605\u8bfb\u4e0b\u4e00\u7ae0\uff0c\u7136\u540e\u518d\u56de\u987e\u672c\u8282\u5185\u5bb9\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 * \u7b26\u53f7\u7684\u662f\u9009\u8bfb\u7ae0\u8282\u3002\u5982\u679c\u4f60\u65f6\u95f4\u6709\u9650\u6216\u611f\u5230\u7406\u89e3\u56f0\u96be\uff0c\u53ef\u4ee5\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":"

    \u5728\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\uff0c\u4f8b\u5982 byte \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\u539f\u7801\u3001\u53cd\u7801\u3001\u8865\u7801\u7684\u76f8\u5173\u77e5\u8bc6\u3002

    \u9996\u5148\u9700\u8981\u6307\u51fa\uff0c\u6570\u5b57\u662f\u4ee5\u201c\u8865\u7801\u201d\u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u4e2d\u7684\u3002\u5728\u5206\u6790\u8fd9\u6837\u505a\u7684\u539f\u56e0\u4e4b\u524d\uff0c\u9996\u5148\u7ed9\u51fa\u4e09\u8005\u7684\u5b9a\u4e49\u3002

    • \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

    \u56fe 3-4 \u5c55\u793a\u4e86\u539f\u7801\u3001\u53cd\u7801\u548c\u8865\u7801\u4e4b\u95f4\u7684\u8f6c\u6362\u65b9\u6cd5\u3002

    \u56fe 3-4 \u00a0 \u539f\u7801\u3001\u53cd\u7801\u4e0e\u8865\u7801\u4e4b\u95f4\u7684\u76f8\u4e92\u8f6c\u6362

    \u300c\u539f\u7801 sign-magnitude\u300d\u867d\u7136\u6700\u76f4\u89c2\uff0c\u4f46\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\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 & \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline & = 1000 \\; 0011 \\newline & \\rightarrow -3 \\end{aligned} \\]

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

    \\[ \\begin{aligned} & 1 + (-2) \\newline & \\rightarrow 0000 \\; 0001 \\; \\text{(\u539f\u7801)} + 1000 \\; 0010 \\; \\text{(\u539f\u7801)} \\newline & = 0000 \\; 0001 \\; \\text{(\u53cd\u7801)} + 1111 \\; 1101 \\; \\text{(\u53cd\u7801)} \\newline & = 1111 \\; 1110 \\; \\text{(\u53cd\u7801)} \\newline & = 1000 \\; 0001 \\; \\text{(\u539f\u7801)} \\newline & \\rightarrow -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\u4e24\u4e2a\u4e0d\u540c\u7684\u4e8c\u8fdb\u5236\u7f16\u7801\uff0c\u8fd9\u53ef\u80fd\u4f1a\u5e26\u6765\u6b67\u4e49\u3002\u6bd4\u5982\u5728\u6761\u4ef6\u5224\u65ad\u4e2d\uff0c\u5982\u679c\u6ca1\u6709\u533a\u5206\u6b63\u96f6\u548c\u8d1f\u96f6\uff0c\u5219\u53ef\u80fd\u4f1a\u5bfc\u81f4\u5224\u65ad\u7ed3\u679c\u51fa\u9519\u3002\u800c\u5982\u679c\u6211\u4eec\u60f3\u5904\u7406\u6b63\u96f6\u548c\u8d1f\u96f6\u6b67\u4e49\uff0c\u5219\u9700\u8981\u5f15\u5165\u989d\u5916\u7684\u5224\u65ad\u64cd\u4f5c\uff0c\u8fd9\u53ef\u80fd\u4f1a\u964d\u4f4e\u8ba1\u7b97\u673a\u7684\u8fd0\u7b97\u6548\u7387\u3002

    \\[ \\begin{aligned} +0 & \\rightarrow 0000 \\; 0000 \\newline -0 & \\rightarrow 1000 \\; 0000 \\end{aligned} \\]

    \u4e0e\u539f\u7801\u4e00\u6837\uff0c\u53cd\u7801\u4e5f\u5b58\u5728\u6b63\u8d1f\u96f6\u6b67\u4e49\u95ee\u9898\uff0c\u56e0\u6b64\u8ba1\u7b97\u673a\u8fdb\u4e00\u6b65\u5f15\u5165\u4e86\u300c\u8865\u7801 2's complement\u300d\u3002\u6211\u4eec\u5148\u6765\u89c2\u5bdf\u4e00\u4e0b\u8d1f\u96f6\u7684\u539f\u7801\u3001\u53cd\u7801\u3001\u8865\u7801\u7684\u8f6c\u6362\u8fc7\u7a0b\uff1a

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

    \u5728\u8d1f\u96f6\u7684\u53cd\u7801\u57fa\u7840\u4e0a\u52a0 \\(1\\) \u4f1a\u4ea7\u751f\u8fdb\u4f4d\uff0c\u4f46 byte \u7c7b\u578b\u7684\u957f\u5ea6\u53ea\u6709 8 \u4f4d\uff0c\u56e0\u6b64\u6ea2\u51fa\u5230\u7b2c 9 \u4f4d\u7684 \\(1\\) \u4f1a\u88ab\u820d\u5f03\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u8d1f\u96f6\u7684\u8865\u7801\u4e3a \\(0000 \\; 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\u6b63\u8d1f\u96f6\u6b67\u4e49\u4ece\u800c\u5f97\u5230\u89e3\u51b3\u3002

    \u8fd8\u5269\u6700\u540e\u4e00\u4e2a\u7591\u60d1\uff1abyte \u7c7b\u578b\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\u53ef\u4ee5\u4e92\u76f8\u8f6c\u6362\u3002

    \u7136\u800c\uff0c\u8865\u7801 \\(1000 \\; 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 \\; 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 \\; 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 & \\rightarrow 1111 \\; 1111 \\; \\text{(\u539f\u7801)} + 1000 \\; 0001 \\; \\text{(\u539f\u7801)} \\newline & = 1000 \\; 0000 \\; \\text{(\u53cd\u7801)} + 1111 \\; 1110 \\; \\text{(\u53cd\u7801)} \\newline & = 1000 \\; 0001 \\; \\text{(\u8865\u7801)} + 1111 \\; 1111 \\; \\text{(\u8865\u7801)} \\newline & = 1000 \\; 0000 \\; \\text{(\u8865\u7801)} \\newline & \\rightarrow -128 \\end{aligned} \\]

    \u4f60\u53ef\u80fd\u5df2\u7ecf\u53d1\u73b0\u4e86\uff0c\u4e0a\u8ff0\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\u8fd0\u7b97\u901f\u5ea6\u66f4\u5feb\u3002

    \u8bf7\u6ce8\u610f\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\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\u987b\u7279\u522b\u5904\u7406\u6b63\u8d1f\u96f6\u7684\u6b67\u4e49\u95ee\u9898\u3002\u8fd9\u5927\u5927\u7b80\u5316\u4e86\u786c\u4ef6\u8bbe\u8ba1\uff0c\u63d0\u9ad8\u4e86\u8fd0\u7b97\u6548\u7387\u3002

    \u8865\u7801\u7684\u8bbe\u8ba1\u975e\u5e38\u7cbe\u5999\uff0c\u56e0\u7bc7\u5e45\u5173\u7cfb\u6211\u4eec\u5c31\u5148\u4ecb\u7ecd\u5230\u8fd9\u91cc\uff0c\u5efa\u8bae\u6709\u5174\u8da3\u7684\u8bfb\u8005\u8fdb\u4e00\u6b65\u6df1\u5165\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 \u5b57\u8282 \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\u8bb0\u4e00\u4e2a 32 \u6bd4\u7279\u957f\u5ea6\u7684\u4e8c\u8fdb\u5236\u6570\u4e3a\uff1a

    \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\]

    \u6839\u636e IEEE 754 \u6807\u51c6\uff0c32-bit \u957f\u5ea6\u7684 float \u7531\u4ee5\u4e0b\u4e09\u4e2a\u90e8\u5206\u6784\u6210\u3002

    • \u7b26\u53f7\u4f4d \\(\\mathrm{S}\\) \uff1a\u5360 1 \u4f4d \uff0c\u5bf9\u5e94 \\(b_{31}\\) \u3002
    • \u6307\u6570\u4f4d \\(\\mathrm{E}\\) \uff1a\u5360 8 \u4f4d \uff0c\u5bf9\u5e94 \\(b_{30} b_{29} \\ldots b_{23}\\) \u3002
    • \u5206\u6570\u4f4d \\(\\mathrm{N}\\) \uff1a\u5360 23 \u4f4d \uff0c\u5bf9\u5e94 \\(b_{22} b_{21} \\ldots b_0\\) \u3002

    \u4e8c\u8fdb\u5236\u6570 float \u5bf9\u5e94\u503c\u7684\u8ba1\u7b97\u65b9\u6cd5\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\uff1a

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

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

    \\[ \\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} \\]

    \u56fe 3-5 \u00a0 IEEE 754 \u6807\u51c6\u4e0b\u7684 float \u7684\u8ba1\u7b97\u793a\u4f8b

    \u89c2\u5bdf\u56fe 3-5 \uff0c\u7ed9\u5b9a\u4e00\u4e2a\u793a\u4f8b\u6570\u636e \\(\\mathrm{S} = 0\\) \uff0c \\(\\mathrm{E} = 124\\) \uff0c\\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) \uff0c\u5219\u6709\uff1a

    \\[ \\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 \u6bd4\u7279\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

    \u5982\u8868 3-2 \u6240\u793a\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

    \u8868 3-2 \u00a0 \u6307\u6570\u4f4d\u542b\u4e49

    \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}\\)

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u6b21\u6b63\u89c4\u6570\u663e\u8457\u63d0\u5347\u4e86\u6d6e\u70b9\u6570\u7684\u7cbe\u5ea6\u3002\u6700\u5c0f\u6b63\u6b63\u89c4\u6570\u4e3a \\(2^{-126}\\) \uff0c\u6700\u5c0f\u6b63\u6b21\u6b63\u89c4\u6570\u4e3a \\(2^{-126} \\times 2^{-23}\\) \u3002

    \u53cc\u7cbe\u5ea6 double \u4e5f\u91c7\u7528\u7c7b\u4f3c\u4e8e float \u7684\u8868\u793a\u65b9\u6cd5\uff0c\u5728\u6b64\u4e0d\u505a\u8d58\u8ff0\u3002

    "},{"location":"chapter_data_structure/summary/","title":"3.5 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_data_structure/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","text":"
    • \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\u6570\u636e\u7ed3\u6784\u548c\u975e\u7ebf\u6027\u6570\u636e\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\u5206\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
    • \u8ba1\u7b97\u673a\u4e2d\u7684\u57fa\u672c\u6570\u636e\u7c7b\u578b\u5305\u62ec\u6574\u6570 byte\u3001short\u3001int\u3001long \uff0c\u6d6e\u70b9\u6570 float\u3001double \uff0c\u5b57\u7b26 char \u548c\u5e03\u5c14 bool \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\u53ef\u4ee5\u76f8\u4e92\u8f6c\u6362\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\u56e0\u6b64\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\u4e0a\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 \u5360\u7528\u7684\u7a7a\u95f4\u6bd4 UTF-8 \u66f4\u5c0f\u3002Java \u548c C# \u7b49\u7f16\u7a0b\u8bed\u8a00\u9ed8\u8ba4\u4f7f\u7528 UTF-16 \u7f16\u7801\u3002
    "},{"location":"chapter_data_structure/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u94fe\u5f0f\u5730\u5740\u201d\uff08\u540e\u7eed\u201c\u54c8\u5e0c\u51b2\u7a81\u201d\u7ae0\u8282\u4f1a\u8bb2\uff09\uff1a\u6570\u7ec4\u4e2d\u6bcf\u4e2a\u6876\u6307\u5411\u4e00\u4e2a\u94fe\u8868\uff0c\u5f53\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

    \u4ece\u5b58\u50a8\u7684\u89d2\u5ea6\u6765\u770b\uff0c\u54c8\u5e0c\u8868\u7684\u5e95\u5c42\u662f\u6570\u7ec4\uff0c\u5176\u4e2d\u6bcf\u4e00\u4e2a\u6876\u69fd\u4f4d\u53ef\u80fd\u5305\u542b\u4e00\u4e2a\u503c\uff0c\u4e5f\u53ef\u80fd\u5305\u542b\u4e00\u4e2a\u94fe\u8868\u6216\u4e00\u68f5\u6811\u3002\u56e0\u6b64\uff0c\u54c8\u5e0c\u8868\u53ef\u80fd\u540c\u65f6\u5305\u542b\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff08\u6570\u7ec4\u3001\u94fe\u8868\uff09\u548c\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff08\u6811\uff09\u3002

    Q\uff1achar \u7c7b\u578b\u7684\u957f\u5ea6\u662f 1 \u5b57\u8282\u5417\uff1f

    char \u7c7b\u578b\u7684\u957f\u5ea6\u7531\u7f16\u7a0b\u8bed\u8a00\u91c7\u7528\u7684\u7f16\u7801\u65b9\u6cd5\u51b3\u5b9a\u3002\u4f8b\u5982\uff0cJava\u3001JavaScript\u3001TypeScript\u3001C# \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 \u5b57\u8282\u3002

    Q\uff1a\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u4e5f\u79f0\u201c\u9759\u6001\u6570\u636e\u7ed3\u6784\u201d \u662f\u5426\u6709\u6b67\u4e49\uff1f\u6808\u4e5f\u53ef\u4ee5\u8fdb\u884c\u51fa\u6808\u548c\u5165\u6808\u7b49\u64cd\u4f5c\uff0c\u8fd9\u4e9b\u64cd\u4f5c\u90fd\u662f\u201c\u52a8\u6001\u201d\u7684\u3002

    \u6808\u786e\u5b9e\u53ef\u4ee5\u5b9e\u73b0\u52a8\u6001\u7684\u6570\u636e\u64cd\u4f5c\uff0c\u4f46\u6570\u636e\u7ed3\u6784\u4ecd\u7136\u662f\u201c\u9759\u6001\u201d\uff08\u957f\u5ea6\u4e0d\u53ef\u53d8\uff09\u7684\u3002\u5c3d\u7ba1\u57fa\u4e8e\u6570\u7ec4\u7684\u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u52a8\u6001\u5730\u6dfb\u52a0\u6216\u5220\u9664\u5143\u7d20\uff0c\u4f46\u5b83\u4eec\u7684\u5bb9\u91cf\u662f\u56fa\u5b9a\u7684\u3002\u5982\u679c\u6570\u636e\u91cf\u8d85\u51fa\u4e86\u9884\u5206\u914d\u7684\u5927\u5c0f\uff0c\u5c31\u9700\u8981\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u66f4\u5927\u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u65e7\u6570\u7ec4\u7684\u5185\u5bb9\u590d\u5236\u5230\u65b0\u6570\u7ec4\u4e2d\u3002

    Q\uff1a\u5728\u6784\u5efa\u6808\uff08\u961f\u5217\uff09\u7684\u65f6\u5019\uff0c\u672a\u6307\u5b9a\u5b83\u7684\u5927\u5c0f\uff0c\u4e3a\u4ec0\u4e48\u5b83\u4eec\u662f\u201c\u9759\u6001\u6570\u636e\u7ed3\u6784\u201d\u5462\uff1f

    \u5728\u9ad8\u7ea7\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u6211\u4eec\u65e0\u987b\u4eba\u5de5\u6307\u5b9a\u6808\uff08\u961f\u5217\uff09\u7684\u521d\u59cb\u5bb9\u91cf\uff0c\u8fd9\u4e2a\u5de5\u4f5c\u7531\u7c7b\u5185\u90e8\u81ea\u52a8\u5b8c\u6210\u3002\u4f8b\u5982\uff0cJava \u7684 ArrayList \u7684\u521d\u59cb\u5bb9\u91cf\u901a\u5e38\u4e3a 10\u3002\u53e6\u5916\uff0c\u6269\u5bb9\u64cd\u4f5c\u4e5f\u662f\u81ea\u52a8\u5b9e\u73b0\u7684\u3002\u8be6\u89c1\u540e\u7eed\u7684\u201c\u5217\u8868\u201d\u7ae0\u8282\u3002

    "},{"location":"chapter_divide_and_conquer/","title":"\u7b2c 12 \u7ae0 \u00a0 \u5206\u6cbb","text":"

    Abstract

    \u96be\u9898\u88ab\u9010\u5c42\u62c6\u89e3\uff0c\u6bcf\u4e00\u6b21\u7684\u62c6\u89e3\u90fd\u4f7f\u5b83\u53d8\u5f97\u66f4\u4e3a\u7b80\u5355\u3002

    \u5206\u800c\u6cbb\u4e4b\u63ed\u793a\u4e86\u4e00\u4e2a\u91cd\u8981\u7684\u4e8b\u5b9e\uff1a\u4ece\u7b80\u5355\u505a\u8d77\uff0c\u4e00\u5207\u90fd\u4e0d\u518d\u590d\u6742\u3002

    "},{"location":"chapter_divide_and_conquer/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 12.1 \u00a0 \u5206\u6cbb\u7b97\u6cd5
    • 12.2 \u00a0 \u5206\u6cbb\u641c\u7d22\u7b56\u7565
    • 12.3 \u00a0 \u6784\u5efa\u6811\u95ee\u9898
    • 12.4 \u00a0 \u6c49\u8bfa\u5854\u95ee\u9898
    • 12.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_divide_and_conquer/binary_search_recur/","title":"12.2 \u00a0 \u5206\u6cbb\u641c\u7d22\u7b56\u7565","text":"

    \u6211\u4eec\u5df2\u7ecf\u5b66\u8fc7\uff0c\u641c\u7d22\u7b97\u6cd5\u5206\u4e3a\u4e24\u5927\u7c7b\u3002

    • \u66b4\u529b\u641c\u7d22\uff1a\u5b83\u901a\u8fc7\u904d\u5386\u6570\u636e\u7ed3\u6784\u5b9e\u73b0\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002
    • \u81ea\u9002\u5e94\u641c\u7d22\uff1a\u5b83\u5229\u7528\u7279\u6709\u7684\u6570\u636e\u7ec4\u7ec7\u5f62\u5f0f\u6216\u5148\u9a8c\u4fe1\u606f\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe\u5230 \\(O(\\log n)\\) \u751a\u81f3 \\(O(1)\\) \u3002

    \u5b9e\u9645\u4e0a\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u7684\u641c\u7d22\u7b97\u6cd5\u901a\u5e38\u662f\u57fa\u4e8e\u5206\u6cbb\u7b56\u7565\u5b9e\u73b0\u7684\uff0c\u4f8b\u5982\u4e8c\u5206\u67e5\u627e\u548c\u6811\u3002

    • \u4e8c\u5206\u67e5\u627e\u7684\u6bcf\u4e00\u6b65\u90fd\u5c06\u95ee\u9898\uff08\u5728\u6570\u7ec4\u4e2d\u641c\u7d22\u76ee\u6807\u5143\u7d20\uff09\u5206\u89e3\u4e3a\u4e00\u4e2a\u5c0f\u95ee\u9898\uff08\u5728\u6570\u7ec4\u7684\u4e00\u534a\u4e2d\u641c\u7d22\u76ee\u6807\u5143\u7d20\uff09\uff0c\u8fd9\u4e2a\u8fc7\u7a0b\u4e00\u76f4\u6301\u7eed\u5230\u6570\u7ec4\u4e3a\u7a7a\u6216\u627e\u5230\u76ee\u6807\u5143\u7d20\u4e3a\u6b62\u3002
    • \u6811\u662f\u5206\u6cbb\u601d\u60f3\u7684\u4ee3\u8868\uff0c\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u3001AVL \u6811\u3001\u5806\u7b49\u6570\u636e\u7ed3\u6784\u4e2d\uff0c\u5404\u79cd\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7686\u4e3a \\(O(\\log n)\\) \u3002

    \u4e8c\u5206\u67e5\u627e\u7684\u5206\u6cbb\u7b56\u7565\u5982\u4e0b\u6240\u793a\u3002

    • \u95ee\u9898\u53ef\u4ee5\u5206\u89e3\uff1a\u4e8c\u5206\u67e5\u627e\u9012\u5f52\u5730\u5c06\u539f\u95ee\u9898\uff08\u5728\u6570\u7ec4\u4e2d\u8fdb\u884c\u67e5\u627e\uff09\u5206\u89e3\u4e3a\u5b50\u95ee\u9898\uff08\u5728\u6570\u7ec4\u7684\u4e00\u534a\u4e2d\u8fdb\u884c\u67e5\u627e\uff09\uff0c\u8fd9\u662f\u901a\u8fc7\u6bd4\u8f83\u4e2d\u95f4\u5143\u7d20\u548c\u76ee\u6807\u5143\u7d20\u6765\u5b9e\u73b0\u7684\u3002
    • \u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff1a\u5728\u4e8c\u5206\u67e5\u627e\u4e2d\uff0c\u6bcf\u8f6e\u53ea\u5904\u7406\u4e00\u4e2a\u5b50\u95ee\u9898\uff0c\u5b83\u4e0d\u53d7\u5176\u4ed6\u5b50\u95ee\u9898\u7684\u5f71\u54cd\u3002
    • \u5b50\u95ee\u9898\u7684\u89e3\u65e0\u987b\u5408\u5e76\uff1a\u4e8c\u5206\u67e5\u627e\u65e8\u5728\u67e5\u627e\u4e00\u4e2a\u7279\u5b9a\u5143\u7d20\uff0c\u56e0\u6b64\u4e0d\u9700\u8981\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u8fdb\u884c\u5408\u5e76\u3002\u5f53\u5b50\u95ee\u9898\u5f97\u5230\u89e3\u51b3\u65f6\uff0c\u539f\u95ee\u9898\u4e5f\u4f1a\u540c\u65f6\u5f97\u5230\u89e3\u51b3\u3002

    \u5206\u6cbb\u80fd\u591f\u63d0\u5347\u641c\u7d22\u6548\u7387\uff0c\u672c\u8d28\u4e0a\u662f\u56e0\u4e3a\u66b4\u529b\u641c\u7d22\u6bcf\u8f6e\u53ea\u80fd\u6392\u9664\u4e00\u4e2a\u9009\u9879\uff0c\u800c\u5206\u6cbb\u641c\u7d22\u6bcf\u8f6e\u53ef\u4ee5\u6392\u9664\u4e00\u534a\u9009\u9879\u3002

    "},{"location":"chapter_divide_and_conquer/binary_search_recur/#1","title":"1. \u00a0 \u57fa\u4e8e\u5206\u6cbb\u5b9e\u73b0\u4e8c\u5206\u67e5\u627e","text":"

    \u5728\u4e4b\u524d\u7684\u7ae0\u8282\u4e2d\uff0c\u4e8c\u5206\u67e5\u627e\u662f\u57fa\u4e8e\u9012\u63a8\uff08\u8fed\u4ee3\uff09\u5b9e\u73b0\u7684\u3002\u73b0\u5728\u6211\u4eec\u57fa\u4e8e\u5206\u6cbb\uff08\u9012\u5f52\uff09\u6765\u5b9e\u73b0\u5b83\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6709\u5e8f\u6570\u7ec4 nums \uff0c\u5176\u4e2d\u6240\u6709\u5143\u7d20\u90fd\u662f\u552f\u4e00\u7684\uff0c\u8bf7\u67e5\u627e\u5143\u7d20 target \u3002

    \u4ece\u5206\u6cbb\u89d2\u5ea6\uff0c\u6211\u4eec\u5c06\u641c\u7d22\u533a\u95f4 \\([i, j]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\u8bb0\u4e3a \\(f(i, j)\\) \u3002

    \u4ee5\u539f\u95ee\u9898 \\(f(0, n-1)\\) \u4e3a\u8d77\u59cb\u70b9\uff0c\u901a\u8fc7\u4ee5\u4e0b\u6b65\u9aa4\u8fdb\u884c\u4e8c\u5206\u67e5\u627e\u3002

    1. \u8ba1\u7b97\u641c\u7d22\u533a\u95f4 \\([i, j]\\) \u7684\u4e2d\u70b9 \\(m\\) \uff0c\u6839\u636e\u5b83\u6392\u9664\u4e00\u534a\u641c\u7d22\u533a\u95f4\u3002
    2. \u9012\u5f52\u6c42\u89e3\u89c4\u6a21\u51cf\u5c0f\u4e00\u534a\u7684\u5b50\u95ee\u9898\uff0c\u53ef\u80fd\u4e3a \\(f(i, m-1)\\) \u6216 \\(f(m+1, j)\\) \u3002
    3. \u5faa\u73af\u7b2c 1. \u6b65\u548c\u7b2c 2. \u6b65\uff0c\u76f4\u81f3\u627e\u5230 target \u6216\u533a\u95f4\u4e3a\u7a7a\u65f6\u8fd4\u56de\u3002

    \u56fe 12-4 \u5c55\u793a\u4e86\u5728\u6570\u7ec4\u4e2d\u4e8c\u5206\u67e5\u627e\u5143\u7d20 \\(6\\) \u7684\u5206\u6cbb\u8fc7\u7a0b\u3002

    \u56fe 12-4 \u00a0 \u4e8c\u5206\u67e5\u627e\u7684\u5206\u6cbb\u8fc7\u7a0b

    \u5728\u5b9e\u73b0\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u58f0\u660e\u4e00\u4e2a\u9012\u5f52\u51fd\u6570 dfs() \u6765\u6c42\u89e3\u95ee\u9898 \\(f(i, j)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_recur.py
    def dfs(nums: list[int], target: int, i: int, j: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j)\"\"\"\n    # \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if i > j:\n        return -1\n    # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    m = (i + j) // 2\n    if nums[m] < target:\n        # \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] > target:\n        # \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1)\n    else:\n        # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m\n\ndef binary_search(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\"\"\"\n    n = len(nums)\n    # \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n
    binary_search_recur.cpp
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint dfs(vector<int> &nums, int target, int i, int j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    int m = (i + j) / 2;\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint binarySearch(vector<int> &nums, int target) {\n    int n = nums.size();\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.java
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    int m = (i + j) / 2;\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.cs
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    int m = (i + j) / 2;\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return DFS(nums, target, 0, n - 1);\n}\n
    binary_search_recur.go
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // \u5982\u679c\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u6ca1\u6709\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if i > j {\n        return -1\n    }\n    //    \u8ba1\u7b97\u7d22\u5f15\u4e2d\u70b9\n    m := i + ((j - i) >> 1)\n    //\u5224\u65ad\u4e2d\u70b9\u4e0e\u76ee\u6807\u5143\u7d20\u5927\u5c0f\n    if nums[m] < target {\n        // \u5c0f\u4e8e\u5219\u9012\u5f52\u53f3\u534a\u6570\u7ec4\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] > target {\n        // \u5c0f\u4e8e\u5219\u9012\u5f52\u5de6\u534a\u6570\u7ec4\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m-1)\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n
    binary_search_recur.swift
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -> Int {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if i > j {\n        return -1\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    let m = (i + j) / 2\n    if nums[m] < target {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] > target {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfunc binarySearch(nums: [Int], target: Int) -> Int {\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n
    binary_search_recur.js
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    const m = i + ((j - i) >> 1);\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.ts
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    const m = i + ((j - i) >> 1);\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.dart
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint dfs(List<int> nums, int target, int i, int j) {\n  // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n  if (i > j) {\n    return -1;\n  }\n  // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n  int m = (i + j) ~/ 2;\n  if (nums[m] < target) {\n    // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] > target) {\n    // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n    return m;\n  }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint binarySearch(List<int> nums, int target) {\n  int n = nums.length;\n  // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n  return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.rs
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfn dfs(nums: &[i32], target: i32, i: i32, j: i32) -> i32 {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if i > j {\n        return -1;\n    }\n    let m: i32 = (i + j) / 2;\n    if nums[m as usize] < target {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] > target {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfn binary_search(nums: &[i32], target: i32) -> i32 {\n    let n = nums.len() as i32;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    dfs(nums, target, 0, n - 1)\n}\n
    binary_search_recur.c
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    int m = (i + j) / 2;\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.kt
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    val m = (i + j) / 2\n    return if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        dfs(nums, target, i, m - 1)\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        m\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n}\n
    binary_search_recur.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{binary_search}\n
    binary_search_recur.zig
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{binarySearch}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","title":"12.3 \u00a0 \u6784\u5efa\u4e8c\u53c9\u6811\u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a\u4e00\u68f5\u4e8c\u53c9\u6811\u7684\u524d\u5e8f\u904d\u5386 preorder \u548c\u4e2d\u5e8f\u904d\u5386 inorder \uff0c\u8bf7\u4ece\u4e2d\u6784\u5efa\u4e8c\u53c9\u6811\uff0c\u8fd4\u56de\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9\u3002\u5047\u8bbe\u4e8c\u53c9\u6811\u4e2d\u6ca1\u6709\u503c\u91cd\u590d\u7684\u8282\u70b9\uff08\u5982\u56fe 12-5 \u6240\u793a\uff09\u3002

    \u56fe 12-5 \u00a0 \u6784\u5efa\u4e8c\u53c9\u6811\u7684\u793a\u4f8b\u6570\u636e

    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1","title":"1. \u00a0 \u5224\u65ad\u662f\u5426\u4e3a\u5206\u6cbb\u95ee\u9898","text":"

    \u539f\u95ee\u9898\u5b9a\u4e49\u4e3a\u4ece preorder \u548c inorder \u6784\u5efa\u4e8c\u53c9\u6811\uff0c\u662f\u4e00\u4e2a\u5178\u578b\u7684\u5206\u6cbb\u95ee\u9898\u3002

    • \u95ee\u9898\u53ef\u4ee5\u5206\u89e3\uff1a\u4ece\u5206\u6cbb\u7684\u89d2\u5ea6\u5207\u5165\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u539f\u95ee\u9898\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\u3001\u6784\u5efa\u53f3\u5b50\u6811\uff0c\u52a0\u4e0a\u4e00\u6b65\u64cd\u4f5c\uff1a\u521d\u59cb\u5316\u6839\u8282\u70b9\u3002\u800c\u5bf9\u4e8e\u6bcf\u68f5\u5b50\u6811\uff08\u5b50\u95ee\u9898\uff09\uff0c\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u590d\u7528\u4ee5\u4e0a\u5212\u5206\u65b9\u6cd5\uff0c\u5c06\u5176\u5212\u5206\u4e3a\u66f4\u5c0f\u7684\u5b50\u6811\uff08\u5b50\u95ee\u9898\uff09\uff0c\u76f4\u81f3\u8fbe\u5230\u6700\u5c0f\u5b50\u95ee\u9898\uff08\u7a7a\u5b50\u6811\uff09\u65f6\u7ec8\u6b62\u3002
    • \u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff1a\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u5b83\u4eec\u4e4b\u95f4\u6ca1\u6709\u4ea4\u96c6\u3002\u5728\u6784\u5efa\u5de6\u5b50\u6811\u65f6\uff0c\u6211\u4eec\u53ea\u9700\u5173\u6ce8\u4e2d\u5e8f\u904d\u5386\u548c\u524d\u5e8f\u904d\u5386\u4e2d\u4e0e\u5de6\u5b50\u6811\u5bf9\u5e94\u7684\u90e8\u5206\u3002\u53f3\u5b50\u6811\u540c\u7406\u3002
    • \u5b50\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u5408\u5e76\uff1a\u4e00\u65e6\u5f97\u5230\u4e86\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\uff08\u5b50\u95ee\u9898\u7684\u89e3\uff09\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5c06\u5b83\u4eec\u94fe\u63a5\u5230\u6839\u8282\u70b9\u4e0a\uff0c\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002
    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2","title":"2. \u00a0 \u5982\u4f55\u5212\u5206\u5b50\u6811","text":"

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u8fd9\u9053\u9898\u53ef\u4ee5\u4f7f\u7528\u5206\u6cbb\u6765\u6c42\u89e3\uff0c\u4f46\u5982\u4f55\u901a\u8fc7\u524d\u5e8f\u904d\u5386 preorder \u548c\u4e2d\u5e8f\u904d\u5386 inorder \u6765\u5212\u5206\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u5462\uff1f

    \u6839\u636e\u5b9a\u4e49\uff0cpreorder \u548c inorder \u90fd\u53ef\u4ee5\u5212\u5206\u4e3a\u4e09\u4e2a\u90e8\u5206\u3002

    • \u524d\u5e8f\u904d\u5386\uff1a[ \u6839\u8282\u70b9 | \u5de6\u5b50\u6811 | \u53f3\u5b50\u6811 ] \uff0c\u4f8b\u5982\u56fe 12-5 \u7684\u6811\u5bf9\u5e94 [ 3 | 9 | 2 1 7 ] \u3002
    • \u4e2d\u5e8f\u904d\u5386\uff1a[ \u5de6\u5b50\u6811 | \u6839\u8282\u70b9 \uff5c \u53f3\u5b50\u6811 ] \uff0c\u4f8b\u5982\u56fe 12-5 \u7684\u6811\u5bf9\u5e94 [ 9 | 3 | 1 2 7 ] \u3002

    \u4ee5\u4e0a\u56fe\u6570\u636e\u4e3a\u4f8b\uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u56fe 12-6 \u6240\u793a\u7684\u6b65\u9aa4\u5f97\u5230\u5212\u5206\u7ed3\u679c\u3002

    1. \u524d\u5e8f\u904d\u5386\u7684\u9996\u5143\u7d20 3 \u662f\u6839\u8282\u70b9\u7684\u503c\u3002
    2. \u67e5\u627e\u6839\u8282\u70b9 3 \u5728 inorder \u4e2d\u7684\u7d22\u5f15\uff0c\u5229\u7528\u8be5\u7d22\u5f15\u53ef\u5c06 inorder \u5212\u5206\u4e3a [ 9 | 3 \uff5c 1 2 7 ] \u3002
    3. \u6839\u636e inorder \u7684\u5212\u5206\u7ed3\u679c\uff0c\u6613\u5f97\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u7684\u8282\u70b9\u6570\u91cf\u5206\u522b\u4e3a 1 \u548c 3 \uff0c\u4ece\u800c\u53ef\u5c06 preorder \u5212\u5206\u4e3a [ 3 | 9 | 2 1 7 ] \u3002

    \u56fe 12-6 \u00a0 \u5728\u524d\u5e8f\u904d\u5386\u548c\u4e2d\u5e8f\u904d\u5386\u4e2d\u5212\u5206\u5b50\u6811

    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3","title":"3. \u00a0 \u57fa\u4e8e\u53d8\u91cf\u63cf\u8ff0\u5b50\u6811\u533a\u95f4","text":"

    \u6839\u636e\u4ee5\u4e0a\u5212\u5206\u65b9\u6cd5\uff0c\u6211\u4eec\u5df2\u7ecf\u5f97\u5230\u6839\u8282\u70b9\u3001\u5de6\u5b50\u6811\u3001\u53f3\u5b50\u6811\u5728 preorder \u548c inorder \u4e2d\u7684\u7d22\u5f15\u533a\u95f4\u3002\u800c\u4e3a\u4e86\u63cf\u8ff0\u8fd9\u4e9b\u7d22\u5f15\u533a\u95f4\uff0c\u6211\u4eec\u9700\u8981\u501f\u52a9\u51e0\u4e2a\u6307\u9488\u53d8\u91cf\u3002

    • \u5c06\u5f53\u524d\u6811\u7684\u6839\u8282\u70b9\u5728 preorder \u4e2d\u7684\u7d22\u5f15\u8bb0\u4e3a \\(i\\) \u3002
    • \u5c06\u5f53\u524d\u6811\u7684\u6839\u8282\u70b9\u5728 inorder \u4e2d\u7684\u7d22\u5f15\u8bb0\u4e3a \\(m\\) \u3002
    • \u5c06\u5f53\u524d\u6811\u5728 inorder \u4e2d\u7684\u7d22\u5f15\u533a\u95f4\u8bb0\u4e3a \\([l, r]\\) \u3002

    \u5982\u8868 12-1 \u6240\u793a\uff0c\u901a\u8fc7\u4ee5\u4e0a\u53d8\u91cf\u5373\u53ef\u8868\u793a\u6839\u8282\u70b9\u5728 preorder \u4e2d\u7684\u7d22\u5f15\uff0c\u4ee5\u53ca\u5b50\u6811\u5728 inorder \u4e2d\u7684\u7d22\u5f15\u533a\u95f4\u3002

    \u8868 12-1 \u00a0 \u6839\u8282\u70b9\u548c\u5b50\u6811\u5728\u524d\u5e8f\u904d\u5386\u548c\u4e2d\u5e8f\u904d\u5386\u4e2d\u7684\u7d22\u5f15

    \u6839\u8282\u70b9\u5728 preorder \u4e2d\u7684\u7d22\u5f15 \u5b50\u6811\u5728 inorder \u4e2d\u7684\u7d22\u5f15\u533a\u95f4 \u5f53\u524d\u6811 \\(i\\) \\([l, r]\\) \u5de6\u5b50\u6811 \\(i + 1\\) \\([l, m-1]\\) \u53f3\u5b50\u6811 \\(i + 1 + (m - l)\\) \\([m+1, r]\\)

    \u8bf7\u6ce8\u610f\uff0c\u53f3\u5b50\u6811\u6839\u8282\u70b9\u7d22\u5f15\u4e2d\u7684 \\((m-l)\\) \u7684\u542b\u4e49\u662f\u201c\u5de6\u5b50\u6811\u7684\u8282\u70b9\u6570\u91cf\u201d\uff0c\u5efa\u8bae\u7ed3\u5408\u56fe 12-7 \u7406\u89e3\u3002

    \u56fe 12-7 \u00a0 \u6839\u8282\u70b9\u548c\u5de6\u53f3\u5b50\u6811\u7684\u7d22\u5f15\u533a\u95f4\u8868\u793a

    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4","title":"4. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u4e3a\u4e86\u63d0\u5347\u67e5\u8be2 \\(m\\) \u7684\u6548\u7387\uff0c\u6211\u4eec\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868 hmap \u6765\u5b58\u50a8\u6570\u7ec4 inorder \u4e2d\u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig build_tree.py
    def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -> TreeNode | None:\n    \"\"\"\u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb\"\"\"\n    # \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if r - l < 0:\n        return None\n    # \u521d\u59cb\u5316\u6839\u8282\u70b9\n    root = TreeNode(preorder[i])\n    # \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    m = inorder_map[preorder[i]]\n    # \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # \u8fd4\u56de\u6839\u8282\u70b9\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -> TreeNode | None:\n    \"\"\"\u6784\u5efa\u4e8c\u53c9\u6811\"\"\"\n    # \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n
    build_tree.cpp
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode *dfs(vector<int> &preorder, unordered_map<int, int> &inorderMap, int i, int l, int r) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0)\n        return NULL;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    TreeNode *root = new TreeNode(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    int m = inorderMap[preorder[i]];\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root->left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    unordered_map<int, int> inorderMap;\n    for (int i = 0; i < inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n
    build_tree.java
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0)\n        return null;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    TreeNode root = new TreeNode(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    int m = inorderMap.get(preorder[i]);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    Map<Integer, Integer> inorderMap = new HashMap<>();\n    for (int i = 0; i < inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n
    build_tree.cs
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode? DFS(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0)\n        return null;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    TreeNode root = new(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    int m = inorderMap[preorder[i]];\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    Dictionary<int, int> inorderMap = [];\n    for (int i = 0; i < inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n
    build_tree.go
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if r-l < 0 {\n        return nil\n    }\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    root := NewTreeNode(preorder[i])\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    m := inorderMap[preorder[i]]\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i < len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n
    build_tree.swift
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if r - l < 0 {\n        return nil\n    }\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    let root = TreeNode(x: preorder[i])\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    let m = inorderMap[preorder[i]]!\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfunc buildTree(preorder: [Int], inorder: [Int]) -> TreeNode? {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n
    build_tree.js
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0) return null;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    const root = new TreeNode(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    const m = inorderMap.get(preorder[i]);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfunction buildTree(preorder, inorder) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    let inorderMap = new Map();\n    for (let i = 0; i < inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n
    build_tree.ts
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map<number, number>,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0) return null;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    const m = inorderMap.get(preorder[i]);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    let inorderMap = new Map<number, number>();\n    for (let i = 0; i < inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n
    build_tree.dart
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode? dfs(\n  List<int> preorder,\n  Map<int, int> inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n  if (r - l < 0) {\n    return null;\n  }\n  // \u521d\u59cb\u5316\u6839\u8282\u70b9\n  TreeNode? root = TreeNode(preorder[i]);\n  // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n  int m = inorderMap[preorder[i]]!;\n  // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // \u8fd4\u56de\u6839\u8282\u70b9\n  return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode? buildTree(List<int> preorder, List<int> inorder) {\n  // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n  Map<int, int> inorderMap = {};\n  for (int i = 0; i < inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n
    build_tree.rs
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfn dfs(\n    preorder: &[i32],\n    inorder_map: &HashMap<i32, i32>,\n    i: i32,\n    l: i32,\n    r: i32,\n) -> Option<Rc<RefCell<TreeNode>>> {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if r - l < 0 {\n        return None;\n    }\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    let root = TreeNode::new(preorder[i as usize]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    let m = inorder_map.get(&preorder[i as usize]).unwrap();\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    Some(root)\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    let mut inorder_map: HashMap<i32, i32> = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n
    build_tree.c
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0)\n        return NULL;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root->val = preorder[i];\n    root->left = NULL;\n    root->right = NULL;\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    int m = inorderMap[preorder[i]];\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root->left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i < inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n
    build_tree.kt
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfun dfs(preorder: IntArray, inorderMap: Map<Int?, Int?>, i: Int, l: Int, r: Int): TreeNode? {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0) return null\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    val root = TreeNode(preorder[i])\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    val m = inorderMap[preorder[i]]!!\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    val inorderMap: MutableMap<Int?, Int?> = HashMap()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n
    build_tree.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{build_tree}\n
    build_tree.zig
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{buildTree}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 12-8 \u5c55\u793a\u4e86\u6784\u5efa\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u8fc7\u7a0b\uff0c\u5404\u4e2a\u8282\u70b9\u662f\u5728\u5411\u4e0b\u201c\u9012\u201d\u7684\u8fc7\u7a0b\u4e2d\u5efa\u7acb\u7684\uff0c\u800c\u5404\u6761\u8fb9\uff08\u5f15\u7528\uff09\u662f\u5728\u5411\u4e0a\u201c\u5f52\u201d\u7684\u8fc7\u7a0b\u4e2d\u5efa\u7acb\u7684\u3002

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

    \u56fe 12-8 \u00a0 \u6784\u5efa\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u8fc7\u7a0b

    \u6bcf\u4e2a\u9012\u5f52\u51fd\u6570\u5185\u7684\u524d\u5e8f\u904d\u5386 preorder \u548c\u4e2d\u5e8f\u904d\u5386 inorder \u7684\u5212\u5206\u7ed3\u679c\u5982\u56fe 12-9 \u6240\u793a\u3002

    \u56fe 12-9 \u00a0 \u6bcf\u4e2a\u9012\u5f52\u51fd\u6570\u4e2d\u7684\u5212\u5206\u7ed3\u679c

    \u8bbe\u6811\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(n\\) \uff0c\u521d\u59cb\u5316\u6bcf\u4e00\u4e2a\u8282\u70b9\uff08\u6267\u884c\u4e00\u4e2a\u9012\u5f52\u51fd\u6570 dfs() \uff09\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\u3002\u56e0\u6b64\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    \u54c8\u5e0c\u8868\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u5373\u4e8c\u53c9\u6811\u9000\u5316\u4e3a\u94fe\u8868\u65f6\uff0c\u9012\u5f52\u6df1\u5ea6\u8fbe\u5230 \\(n\\) \uff0c\u4f7f\u7528 \\(O(n)\\) \u7684\u6808\u5e27\u7a7a\u95f4\u3002\u56e0\u6b64\u603b\u4f53\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/","title":"12.1 \u00a0 \u5206\u6cbb\u7b97\u6cd5","text":"

    \u300c\u5206\u6cbb divide and conquer\u300d\uff0c\u5168\u79f0\u5206\u800c\u6cbb\u4e4b\uff0c\u662f\u4e00\u79cd\u975e\u5e38\u91cd\u8981\u4e14\u5e38\u89c1\u7684\u7b97\u6cd5\u7b56\u7565\u3002\u5206\u6cbb\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u5b9e\u73b0\uff0c\u5305\u62ec\u201c\u5206\u201d\u548c\u201c\u6cbb\u201d\u4e24\u4e2a\u6b65\u9aa4\u3002

    1. \u5206\uff08\u5212\u5206\u9636\u6bb5\uff09\uff1a\u9012\u5f52\u5730\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u4e24\u4e2a\u6216\u591a\u4e2a\u5b50\u95ee\u9898\uff0c\u76f4\u81f3\u5230\u8fbe\u6700\u5c0f\u5b50\u95ee\u9898\u65f6\u7ec8\u6b62\u3002
    2. \u6cbb\uff08\u5408\u5e76\u9636\u6bb5\uff09\uff1a\u4ece\u5df2\u77e5\u89e3\u7684\u6700\u5c0f\u5b50\u95ee\u9898\u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5730\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u8fdb\u884c\u5408\u5e76\uff0c\u4ece\u800c\u6784\u5efa\u51fa\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u5982\u56fe 12-1 \u6240\u793a\uff0c\u201c\u5f52\u5e76\u6392\u5e8f\u201d\u662f\u5206\u6cbb\u7b56\u7565\u7684\u5178\u578b\u5e94\u7528\u4e4b\u4e00\u3002

    1. \u5206\uff1a\u9012\u5f52\u5730\u5c06\u539f\u6570\u7ec4\uff08\u539f\u95ee\u9898\uff09\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff08\u5b50\u95ee\u9898\uff09\uff0c\u76f4\u5230\u5b50\u6570\u7ec4\u53ea\u5269\u4e00\u4e2a\u5143\u7d20\uff08\u6700\u5c0f\u5b50\u95ee\u9898\uff09\u3002
    2. \u6cbb\uff1a\u4ece\u5e95\u81f3\u9876\u5730\u5c06\u6709\u5e8f\u7684\u5b50\u6570\u7ec4\uff08\u5b50\u95ee\u9898\u7684\u89e3\uff09\u8fdb\u884c\u5408\u5e76\uff0c\u4ece\u800c\u5f97\u5230\u6709\u5e8f\u7684\u539f\u6570\u7ec4\uff08\u539f\u95ee\u9898\u7684\u89e3\uff09\u3002

    \u56fe 12-1 \u00a0 \u5f52\u5e76\u6392\u5e8f\u7684\u5206\u6cbb\u7b56\u7565

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211","title":"12.1.1 \u00a0 \u5982\u4f55\u5224\u65ad\u5206\u6cbb\u95ee\u9898","text":"

    \u4e00\u4e2a\u95ee\u9898\u662f\u5426\u9002\u5408\u4f7f\u7528\u5206\u6cbb\u89e3\u51b3\uff0c\u901a\u5e38\u53ef\u4ee5\u53c2\u8003\u4ee5\u4e0b\u51e0\u4e2a\u5224\u65ad\u4f9d\u636e\u3002

    1. \u95ee\u9898\u53ef\u4ee5\u5206\u89e3\uff1a\u539f\u95ee\u9898\u53ef\u4ee5\u5206\u89e3\u6210\u89c4\u6a21\u66f4\u5c0f\u3001\u7c7b\u4f3c\u7684\u5b50\u95ee\u9898\uff0c\u4ee5\u53ca\u80fd\u591f\u4ee5\u76f8\u540c\u65b9\u5f0f\u9012\u5f52\u5730\u8fdb\u884c\u5212\u5206\u3002
    2. \u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff1a\u5b50\u95ee\u9898\u4e4b\u95f4\u6ca1\u6709\u91cd\u53e0\uff0c\u4e92\u4e0d\u4f9d\u8d56\uff0c\u53ef\u4ee5\u72ec\u7acb\u89e3\u51b3\u3002
    3. \u5b50\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u5408\u5e76\uff1a\u539f\u95ee\u9898\u7684\u89e3\u901a\u8fc7\u5408\u5e76\u5b50\u95ee\u9898\u7684\u89e3\u5f97\u6765\u3002

    \u663e\u7136\uff0c\u5f52\u5e76\u6392\u5e8f\u6ee1\u8db3\u4ee5\u4e0a\u4e09\u4e2a\u5224\u65ad\u4f9d\u636e\u3002

    1. \u95ee\u9898\u53ef\u4ee5\u5206\u89e3\uff1a\u9012\u5f52\u5730\u5c06\u6570\u7ec4\uff08\u539f\u95ee\u9898\uff09\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff08\u5b50\u95ee\u9898\uff09\u3002
    2. \u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff1a\u6bcf\u4e2a\u5b50\u6570\u7ec4\u90fd\u53ef\u4ee5\u72ec\u7acb\u5730\u8fdb\u884c\u6392\u5e8f\uff08\u5b50\u95ee\u9898\u53ef\u4ee5\u72ec\u7acb\u8fdb\u884c\u6c42\u89e3\uff09\u3002
    3. \u5b50\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u5408\u5e76\uff1a\u4e24\u4e2a\u6709\u5e8f\u5b50\u6570\u7ec4\uff08\u5b50\u95ee\u9898\u7684\u89e3\uff09\u53ef\u4ee5\u5408\u5e76\u4e3a\u4e00\u4e2a\u6709\u5e8f\u6570\u7ec4\uff08\u539f\u95ee\u9898\u7684\u89e3\uff09\u3002
    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212","title":"12.1.2 \u00a0 \u901a\u8fc7\u5206\u6cbb\u63d0\u5347\u6548\u7387","text":"

    \u5206\u6cbb\u4e0d\u4ec5\u53ef\u4ee5\u6709\u6548\u5730\u89e3\u51b3\u7b97\u6cd5\u95ee\u9898\uff0c\u5f80\u5f80\u8fd8\u53ef\u4ee5\u63d0\u5347\u7b97\u6cd5\u6548\u7387\u3002\u5728\u6392\u5e8f\u7b97\u6cd5\u4e2d\uff0c\u5feb\u901f\u6392\u5e8f\u3001\u5f52\u5e76\u6392\u5e8f\u3001\u5806\u6392\u5e8f\u76f8\u8f83\u4e8e\u9009\u62e9\u3001\u5192\u6ce1\u3001\u63d2\u5165\u6392\u5e8f\u66f4\u5feb\uff0c\u5c31\u662f\u56e0\u4e3a\u5b83\u4eec\u5e94\u7528\u4e86\u5206\u6cbb\u7b56\u7565\u3002

    \u90a3\u4e48\uff0c\u6211\u4eec\u4e0d\u7981\u53d1\u95ee\uff1a\u4e3a\u4ec0\u4e48\u5206\u6cbb\u53ef\u4ee5\u63d0\u5347\u7b97\u6cd5\u6548\u7387\uff0c\u5176\u5e95\u5c42\u903b\u8f91\u662f\u4ec0\u4e48\uff1f\u6362\u53e5\u8bdd\u8bf4\uff0c\u5c06\u5927\u95ee\u9898\u5206\u89e3\u4e3a\u591a\u4e2a\u5b50\u95ee\u9898\u3001\u89e3\u51b3\u5b50\u95ee\u9898\u3001\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u5408\u5e76\u4e3a\u539f\u95ee\u9898\u7684\u89e3\uff0c\u8fd9\u51e0\u6b65\u7684\u6548\u7387\u4e3a\u4ec0\u4e48\u6bd4\u76f4\u63a5\u89e3\u51b3\u539f\u95ee\u9898\u7684\u6548\u7387\u66f4\u9ad8\uff1f\u8fd9\u4e2a\u95ee\u9898\u53ef\u4ee5\u4ece\u64cd\u4f5c\u6570\u91cf\u548c\u5e76\u884c\u8ba1\u7b97\u4e24\u65b9\u9762\u6765\u8ba8\u8bba\u3002

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1","title":"1. \u00a0 \u64cd\u4f5c\u6570\u91cf\u4f18\u5316","text":"

    \u4ee5\u201c\u5192\u6ce1\u6392\u5e8f\u201d\u4e3a\u4f8b\uff0c\u5176\u5904\u7406\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\u9700\u8981 \\(O(n^2)\\) \u65f6\u95f4\u3002\u5047\u8bbe\u6211\u4eec\u6309\u7167\u56fe 12-2 \u6240\u793a\u7684\u65b9\u5f0f\uff0c\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5904\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u5219\u5212\u5206\u9700\u8981 \\(O(n)\\) \u65f6\u95f4\uff0c\u6392\u5e8f\u6bcf\u4e2a\u5b50\u6570\u7ec4\u9700\u8981 \\(O((n / 2)^2)\\) \u65f6\u95f4\uff0c\u5408\u5e76\u4e24\u4e2a\u5b50\u6570\u7ec4\u9700\u8981 \\(O(n)\\) \u65f6\u95f4\uff0c\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a\uff1a

    \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\]

    \u56fe 12-2 \u00a0 \u5212\u5206\u6570\u7ec4\u524d\u540e\u7684\u5192\u6ce1\u6392\u5e8f

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u8ba1\u7b97\u4ee5\u4e0b\u4e0d\u7b49\u5f0f\uff0c\u5176\u5de6\u8fb9\u548c\u53f3\u8fb9\u5206\u522b\u4e3a\u5212\u5206\u524d\u548c\u5212\u5206\u540e\u7684\u64cd\u4f5c\u603b\u6570\uff1a

    \\[ \\begin{aligned} n^2 & > \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n & > 0 \\newline n(n - 4) & > 0 \\end{aligned} \\]

    \u8fd9\u610f\u5473\u7740\u5f53 \\(n > 4\\) \u65f6\uff0c\u5212\u5206\u540e\u7684\u64cd\u4f5c\u6570\u91cf\u66f4\u5c11\uff0c\u6392\u5e8f\u6548\u7387\u5e94\u8be5\u66f4\u9ad8\u3002\u8bf7\u6ce8\u610f\uff0c\u5212\u5206\u540e\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4ecd\u7136\u662f\u5e73\u65b9\u9636 \\(O(n^2)\\) \uff0c\u53ea\u662f\u590d\u6742\u5ea6\u4e2d\u7684\u5e38\u6570\u9879\u53d8\u5c0f\u4e86\u3002

    \u8fdb\u4e00\u6b65\u60f3\uff0c\u5982\u679c\u6211\u4eec\u628a\u5b50\u6570\u7ec4\u4e0d\u65ad\u5730\u518d\u4ece\u4e2d\u70b9\u5904\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u53ea\u5269\u4e00\u4e2a\u5143\u7d20\u65f6\u505c\u6b62\u5212\u5206\u5462\uff1f\u8fd9\u79cd\u601d\u8def\u5b9e\u9645\u4e0a\u5c31\u662f\u201c\u5f52\u5e76\u6392\u5e8f\u201d\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    \u518d\u601d\u8003\uff0c\u5982\u679c\u6211\u4eec\u591a\u8bbe\u7f6e\u51e0\u4e2a\u5212\u5206\u70b9\uff0c\u5c06\u539f\u6570\u7ec4\u5e73\u5747\u5212\u5206\u4e3a \\(k\\) \u4e2a\u5b50\u6570\u7ec4\u5462\uff1f\u8fd9\u79cd\u60c5\u51b5\u4e0e\u201c\u6876\u6392\u5e8f\u201d\u975e\u5e38\u7c7b\u4f3c\uff0c\u5b83\u975e\u5e38\u9002\u5408\u6392\u5e8f\u6d77\u91cf\u6570\u636e\uff0c\u7406\u8bba\u4e0a\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u8fbe\u5230 \\(O(n + k)\\) \u3002

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2","title":"2. \u00a0 \u5e76\u884c\u8ba1\u7b97\u4f18\u5316","text":"

    \u6211\u4eec\u77e5\u9053\uff0c\u5206\u6cbb\u751f\u6210\u7684\u5b50\u95ee\u9898\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u56e0\u6b64\u901a\u5e38\u53ef\u4ee5\u5e76\u884c\u89e3\u51b3\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u5206\u6cbb\u4e0d\u4ec5\u53ef\u4ee5\u964d\u4f4e\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u8fd8\u6709\u5229\u4e8e\u64cd\u4f5c\u7cfb\u7edf\u7684\u5e76\u884c\u4f18\u5316\u3002

    \u5e76\u884c\u4f18\u5316\u5728\u591a\u6838\u6216\u591a\u5904\u7406\u5668\u7684\u73af\u5883\u4e2d\u5c24\u5176\u6709\u6548\uff0c\u56e0\u4e3a\u7cfb\u7edf\u53ef\u4ee5\u540c\u65f6\u5904\u7406\u591a\u4e2a\u5b50\u95ee\u9898\uff0c\u66f4\u52a0\u5145\u5206\u5730\u5229\u7528\u8ba1\u7b97\u8d44\u6e90\uff0c\u4ece\u800c\u663e\u8457\u51cf\u5c11\u603b\u4f53\u7684\u8fd0\u884c\u65f6\u95f4\u3002

    \u6bd4\u5982\u5728\u56fe 12-3 \u6240\u793a\u7684\u201c\u6876\u6392\u5e8f\u201d\u4e2d\uff0c\u6211\u4eec\u5c06\u6d77\u91cf\u7684\u6570\u636e\u5e73\u5747\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\uff0c\u5219\u53ef\u6240\u6709\u6876\u7684\u6392\u5e8f\u4efb\u52a1\u5206\u6563\u5230\u5404\u4e2a\u8ba1\u7b97\u5355\u5143\uff0c\u5b8c\u6210\u540e\u518d\u5408\u5e76\u7ed3\u679c\u3002

    \u56fe 12-3 \u00a0 \u6876\u6392\u5e8f\u7684\u5e76\u884c\u8ba1\u7b97

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213","title":"12.1.3 \u00a0 \u5206\u6cbb\u5e38\u89c1\u5e94\u7528","text":"

    \u4e00\u65b9\u9762\uff0c\u5206\u6cbb\u53ef\u4ee5\u7528\u6765\u89e3\u51b3\u8bb8\u591a\u7ecf\u5178\u7b97\u6cd5\u95ee\u9898\u3002

    • \u5bfb\u627e\u6700\u8fd1\u70b9\u5bf9\uff1a\u8be5\u7b97\u6cd5\u9996\u5148\u5c06\u70b9\u96c6\u5206\u6210\u4e24\u90e8\u5206\uff0c\u7136\u540e\u5206\u522b\u627e\u51fa\u4e24\u90e8\u5206\u4e2d\u7684\u6700\u8fd1\u70b9\u5bf9\uff0c\u6700\u540e\u627e\u51fa\u8de8\u8d8a\u4e24\u90e8\u5206\u7684\u6700\u8fd1\u70b9\u5bf9\u3002
    • \u5927\u6574\u6570\u4e58\u6cd5\uff1a\u4f8b\u5982 Karatsuba \u7b97\u6cd5\uff0c\u5b83\u5c06\u5927\u6574\u6570\u4e58\u6cd5\u5206\u89e3\u4e3a\u51e0\u4e2a\u8f83\u5c0f\u7684\u6574\u6570\u7684\u4e58\u6cd5\u548c\u52a0\u6cd5\u3002
    • \u77e9\u9635\u4e58\u6cd5\uff1a\u4f8b\u5982 Strassen \u7b97\u6cd5\uff0c\u5b83\u5c06\u5927\u77e9\u9635\u4e58\u6cd5\u5206\u89e3\u4e3a\u591a\u4e2a\u5c0f\u77e9\u9635\u7684\u4e58\u6cd5\u548c\u52a0\u6cd5\u3002
    • \u6c49\u8bfa\u5854\u95ee\u9898\uff1a\u6c49\u8bfa\u5854\u95ee\u9898\u53ef\u4ee5\u901a\u8fc7\u9012\u5f52\u89e3\u51b3\uff0c\u8fd9\u662f\u5178\u578b\u7684\u5206\u6cbb\u7b56\u7565\u5e94\u7528\u3002
    • \u6c42\u89e3\u9006\u5e8f\u5bf9\uff1a\u5728\u4e00\u4e2a\u5e8f\u5217\u4e2d\uff0c\u5982\u679c\u524d\u9762\u7684\u6570\u5b57\u5927\u4e8e\u540e\u9762\u7684\u6570\u5b57\uff0c\u90a3\u4e48\u8fd9\u4e24\u4e2a\u6570\u5b57\u6784\u6210\u4e00\u4e2a\u9006\u5e8f\u5bf9\u3002\u6c42\u89e3\u9006\u5e8f\u5bf9\u95ee\u9898\u53ef\u4ee5\u5229\u7528\u5206\u6cbb\u7684\u601d\u60f3\uff0c\u501f\u52a9\u5f52\u5e76\u6392\u5e8f\u8fdb\u884c\u6c42\u89e3\u3002

    \u53e6\u4e00\u65b9\u9762\uff0c\u5206\u6cbb\u5728\u7b97\u6cd5\u548c\u6570\u636e\u7ed3\u6784\u7684\u8bbe\u8ba1\u4e2d\u5e94\u7528\u5f97\u975e\u5e38\u5e7f\u6cdb\u3002

    • \u4e8c\u5206\u67e5\u627e\uff1a\u4e8c\u5206\u67e5\u627e\u662f\u5c06\u6709\u5e8f\u6570\u7ec4\u4ece\u4e2d\u70b9\u7d22\u5f15\u5904\u5206\u4e3a\u4e24\u90e8\u5206\uff0c\u7136\u540e\u6839\u636e\u76ee\u6807\u503c\u4e0e\u4e2d\u95f4\u5143\u7d20\u503c\u6bd4\u8f83\u7ed3\u679c\uff0c\u51b3\u5b9a\u6392\u9664\u54ea\u4e00\u534a\u533a\u95f4\uff0c\u5e76\u5728\u5269\u4f59\u533a\u95f4\u6267\u884c\u76f8\u540c\u7684\u4e8c\u5206\u64cd\u4f5c\u3002
    • \u5f52\u5e76\u6392\u5e8f\uff1a\u672c\u8282\u5f00\u5934\u5df2\u4ecb\u7ecd\uff0c\u4e0d\u518d\u8d58\u8ff0\u3002
    • \u5feb\u901f\u6392\u5e8f\uff1a\u5feb\u901f\u6392\u5e8f\u662f\u9009\u53d6\u4e00\u4e2a\u57fa\u51c6\u503c\uff0c\u7136\u540e\u628a\u6570\u7ec4\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u4e00\u4e2a\u5b50\u6570\u7ec4\u7684\u5143\u7d20\u6bd4\u57fa\u51c6\u503c\u5c0f\uff0c\u53e6\u4e00\u5b50\u6570\u7ec4\u7684\u5143\u7d20\u6bd4\u57fa\u51c6\u503c\u5927\uff0c\u518d\u5bf9\u8fd9\u4e24\u90e8\u5206\u8fdb\u884c\u76f8\u540c\u7684\u5212\u5206\u64cd\u4f5c\uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u53ea\u5269\u4e0b\u4e00\u4e2a\u5143\u7d20\u3002
    • \u6876\u6392\u5e8f\uff1a\u6876\u6392\u5e8f\u7684\u57fa\u672c\u601d\u60f3\u662f\u5c06\u6570\u636e\u5206\u6563\u5230\u591a\u4e2a\u6876\uff0c\u7136\u540e\u5bf9\u6bcf\u4e2a\u6876\u5185\u7684\u5143\u7d20\u8fdb\u884c\u6392\u5e8f\uff0c\u6700\u540e\u5c06\u5404\u4e2a\u6876\u7684\u5143\u7d20\u4f9d\u6b21\u53d6\u51fa\uff0c\u4ece\u800c\u5f97\u5230\u4e00\u4e2a\u6709\u5e8f\u6570\u7ec4\u3002
    • \u6811\uff1a\u4f8b\u5982\u4e8c\u53c9\u641c\u7d22\u6811\u3001AVL \u6811\u3001\u7ea2\u9ed1\u6811\u3001B \u6811\u3001B+ \u6811\u7b49\uff0c\u5b83\u4eec\u7684\u67e5\u627e\u3001\u63d2\u5165\u548c\u5220\u9664\u7b49\u64cd\u4f5c\u90fd\u53ef\u4ee5\u89c6\u4e3a\u5206\u6cbb\u7b56\u7565\u7684\u5e94\u7528\u3002
    • \u5806\uff1a\u5806\u662f\u4e00\u79cd\u7279\u6b8a\u7684\u5b8c\u5168\u4e8c\u53c9\u6811\uff0c\u5176\u5404\u79cd\u64cd\u4f5c\uff0c\u5982\u63d2\u5165\u3001\u5220\u9664\u548c\u5806\u5316\uff0c\u5b9e\u9645\u4e0a\u90fd\u9690\u542b\u4e86\u5206\u6cbb\u7684\u601d\u60f3\u3002
    • \u54c8\u5e0c\u8868\uff1a\u867d\u7136\u54c8\u5e0c\u8868\u5e76\u4e0d\u76f4\u63a5\u5e94\u7528\u5206\u6cbb\uff0c\u4f46\u67d0\u4e9b\u54c8\u5e0c\u51b2\u7a81\u89e3\u51b3\u65b9\u6848\u95f4\u63a5\u5e94\u7528\u4e86\u5206\u6cbb\u7b56\u7565\uff0c\u4f8b\u5982\uff0c\u94fe\u5f0f\u5730\u5740\u4e2d\u7684\u957f\u94fe\u8868\u4f1a\u88ab\u8f6c\u5316\u4e3a\u7ea2\u9ed1\u6811\uff0c\u4ee5\u63d0\u5347\u67e5\u8be2\u6548\u7387\u3002

    \u53ef\u4ee5\u770b\u51fa\uff0c\u5206\u6cbb\u662f\u4e00\u79cd\u201c\u6da6\u7269\u7ec6\u65e0\u58f0\u201d\u7684\u7b97\u6cd5\u601d\u60f3\uff0c\u9690\u542b\u5728\u5404\u79cd\u7b97\u6cd5\u4e0e\u6570\u636e\u7ed3\u6784\u4e4b\u4e2d\u3002

    "},{"location":"chapter_divide_and_conquer/hanota_problem/","title":"12.4 \u00a0 \u6c49\u8bfa\u5854\u95ee\u9898","text":"

    \u5728\u5f52\u5e76\u6392\u5e8f\u548c\u6784\u5efa\u4e8c\u53c9\u6811\u4e2d\uff0c\u6211\u4eec\u90fd\u662f\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u4e24\u4e2a\u89c4\u6a21\u4e3a\u539f\u95ee\u9898\u4e00\u534a\u7684\u5b50\u95ee\u9898\u3002\u7136\u800c\u5bf9\u4e8e\u6c49\u8bfa\u5854\u95ee\u9898\uff0c\u6211\u4eec\u91c7\u7528\u4e0d\u540c\u7684\u5206\u89e3\u7b56\u7565\u3002

    Question

    \u7ed9\u5b9a\u4e09\u6839\u67f1\u5b50\uff0c\u8bb0\u4e3a A\u3001B \u548c C \u3002\u8d77\u59cb\u72b6\u6001\u4e0b\uff0c\u67f1\u5b50 A \u4e0a\u5957\u7740 \\(n\\) \u4e2a\u5706\u76d8\uff0c\u5b83\u4eec\u4ece\u4e0a\u5230\u4e0b\u6309\u7167\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u6392\u5217\u3002\u6211\u4eec\u7684\u4efb\u52a1\u662f\u8981\u628a\u8fd9 \\(n\\) \u4e2a\u5706\u76d8\u79fb\u5230\u67f1\u5b50 C \u4e0a\uff0c\u5e76\u4fdd\u6301\u5b83\u4eec\u7684\u539f\u6709\u987a\u5e8f\u4e0d\u53d8\uff08\u5982\u56fe 12-10 \u6240\u793a\uff09\u3002\u5728\u79fb\u52a8\u5706\u76d8\u7684\u8fc7\u7a0b\u4e2d\uff0c\u9700\u8981\u9075\u5b88\u4ee5\u4e0b\u89c4\u5219\u3002

    1. \u5706\u76d8\u53ea\u80fd\u4ece\u4e00\u6839\u67f1\u5b50\u9876\u90e8\u62ff\u51fa\uff0c\u4ece\u53e6\u4e00\u6839\u67f1\u5b50\u9876\u90e8\u653e\u5165\u3002
    2. \u6bcf\u6b21\u53ea\u80fd\u79fb\u52a8\u4e00\u4e2a\u5706\u76d8\u3002
    3. \u5c0f\u5706\u76d8\u5fc5\u987b\u65f6\u523b\u4f4d\u4e8e\u5927\u5706\u76d8\u4e4b\u4e0a\u3002

    \u56fe 12-10 \u00a0 \u6c49\u8bfa\u5854\u95ee\u9898\u793a\u4f8b

    \u6211\u4eec\u5c06\u89c4\u6a21\u4e3a \\(i\\) \u7684\u6c49\u8bfa\u5854\u95ee\u9898\u8bb0\u4f5c \\(f(i)\\) \u3002\u4f8b\u5982 \\(f(3)\\) \u4ee3\u8868\u5c06 \\(3\\) \u4e2a\u5706\u76d8\u4ece A \u79fb\u52a8\u81f3 C \u7684\u6c49\u8bfa\u5854\u95ee\u9898\u3002

    "},{"location":"chapter_divide_and_conquer/hanota_problem/#1","title":"1. \u00a0 \u8003\u8651\u57fa\u672c\u60c5\u51b5","text":"

    \u5982\u56fe 12-11 \u6240\u793a\uff0c\u5bf9\u4e8e\u95ee\u9898 \\(f(1)\\) \uff0c\u5373\u5f53\u53ea\u6709\u4e00\u4e2a\u5706\u76d8\u65f6\uff0c\u6211\u4eec\u5c06\u5b83\u76f4\u63a5\u4ece A \u79fb\u52a8\u81f3 C \u5373\u53ef\u3002

    <1><2>

    \u56fe 12-11 \u00a0 \u89c4\u6a21\u4e3a 1 \u7684\u95ee\u9898\u7684\u89e3

    \u5982\u56fe 12-12 \u6240\u793a\uff0c\u5bf9\u4e8e\u95ee\u9898 \\(f(2)\\) \uff0c\u5373\u5f53\u6709\u4e24\u4e2a\u5706\u76d8\u65f6\uff0c\u7531\u4e8e\u8981\u65f6\u523b\u6ee1\u8db3\u5c0f\u5706\u76d8\u5728\u5927\u5706\u76d8\u4e4b\u4e0a\uff0c\u56e0\u6b64\u9700\u8981\u501f\u52a9 B \u6765\u5b8c\u6210\u79fb\u52a8\u3002

    1. \u5148\u5c06\u4e0a\u9762\u7684\u5c0f\u5706\u76d8\u4ece A \u79fb\u81f3 B \u3002
    2. \u518d\u5c06\u5927\u5706\u76d8\u4ece A \u79fb\u81f3 C \u3002
    3. \u6700\u540e\u5c06\u5c0f\u5706\u76d8\u4ece B \u79fb\u81f3 C \u3002
    <1><2><3><4>

    \u56fe 12-12 \u00a0 \u89c4\u6a21\u4e3a 2 \u7684\u95ee\u9898\u7684\u89e3

    \u89e3\u51b3\u95ee\u9898 \\(f(2)\\) \u7684\u8fc7\u7a0b\u53ef\u603b\u7ed3\u4e3a\uff1a\u5c06\u4e24\u4e2a\u5706\u76d8\u501f\u52a9 B \u4ece A \u79fb\u81f3 C \u3002\u5176\u4e2d\uff0cC \u79f0\u4e3a\u76ee\u6807\u67f1\u3001B \u79f0\u4e3a\u7f13\u51b2\u67f1\u3002

    "},{"location":"chapter_divide_and_conquer/hanota_problem/#2","title":"2. \u00a0 \u5b50\u95ee\u9898\u5206\u89e3","text":"

    \u5bf9\u4e8e\u95ee\u9898 \\(f(3)\\) \uff0c\u5373\u5f53\u6709\u4e09\u4e2a\u5706\u76d8\u65f6\uff0c\u60c5\u51b5\u53d8\u5f97\u7a0d\u5fae\u590d\u6742\u4e86\u4e00\u4e9b\u3002

    \u56e0\u4e3a\u5df2\u77e5 \\(f(1)\\) \u548c \\(f(2)\\) \u7684\u89e3\uff0c\u6240\u4ee5\u6211\u4eec\u53ef\u4ece\u5206\u6cbb\u89d2\u5ea6\u601d\u8003\uff0c\u5c06 A \u9876\u90e8\u7684\u4e24\u4e2a\u5706\u76d8\u770b\u4f5c\u4e00\u4e2a\u6574\u4f53\uff0c\u6267\u884c\u56fe 12-13 \u6240\u793a\u7684\u6b65\u9aa4\u3002\u8fd9\u6837\u4e09\u4e2a\u5706\u76d8\u5c31\u88ab\u987a\u5229\u5730\u4ece A \u79fb\u81f3 C \u4e86\u3002

    1. \u4ee4 B \u4e3a\u76ee\u6807\u67f1\u3001C \u4e3a\u7f13\u51b2\u67f1\uff0c\u5c06\u4e24\u4e2a\u5706\u76d8\u4ece A \u79fb\u81f3 B \u3002
    2. \u5c06 A \u4e2d\u5269\u4f59\u7684\u4e00\u4e2a\u5706\u76d8\u4ece A \u76f4\u63a5\u79fb\u52a8\u81f3 C \u3002
    3. \u4ee4 C \u4e3a\u76ee\u6807\u67f1\u3001A \u4e3a\u7f13\u51b2\u67f1\uff0c\u5c06\u4e24\u4e2a\u5706\u76d8\u4ece B \u79fb\u81f3 C \u3002
    <1><2><3><4>

    \u56fe 12-13 \u00a0 \u89c4\u6a21\u4e3a 3 \u7684\u95ee\u9898\u7684\u89e3

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u6211\u4eec\u5c06\u95ee\u9898 \\(f(3)\\) \u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u95ee\u9898 \\(f(2)\\) \u548c\u4e00\u4e2a\u5b50\u95ee\u9898 \\(f(1)\\) \u3002\u6309\u987a\u5e8f\u89e3\u51b3\u8fd9\u4e09\u4e2a\u5b50\u95ee\u9898\u4e4b\u540e\uff0c\u539f\u95ee\u9898\u968f\u4e4b\u5f97\u5230\u89e3\u51b3\u3002\u8fd9\u8bf4\u660e\u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff0c\u800c\u4e14\u89e3\u53ef\u4ee5\u5408\u5e76\u3002

    \u81f3\u6b64\uff0c\u6211\u4eec\u53ef\u603b\u7ed3\u51fa\u56fe 12-14 \u6240\u793a\u7684\u89e3\u51b3\u6c49\u8bfa\u5854\u95ee\u9898\u7684\u5206\u6cbb\u7b56\u7565\uff1a\u5c06\u539f\u95ee\u9898 \\(f(n)\\) \u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u95ee\u9898 \\(f(n-1)\\) \u548c\u4e00\u4e2a\u5b50\u95ee\u9898 \\(f(1)\\) \uff0c\u5e76\u6309\u7167\u4ee5\u4e0b\u987a\u5e8f\u89e3\u51b3\u8fd9\u4e09\u4e2a\u5b50\u95ee\u9898\u3002

    1. \u5c06 \\(n-1\\) \u4e2a\u5706\u76d8\u501f\u52a9 C \u4ece A \u79fb\u81f3 B \u3002
    2. \u5c06\u5269\u4f59 \\(1\\) \u4e2a\u5706\u76d8\u4ece A \u76f4\u63a5\u79fb\u81f3 C \u3002
    3. \u5c06 \\(n-1\\) \u4e2a\u5706\u76d8\u501f\u52a9 A \u4ece B \u79fb\u81f3 C \u3002

    \u5bf9\u4e8e\u8fd9\u4e24\u4e2a\u5b50\u95ee\u9898 \\(f(n-1)\\) \uff0c\u53ef\u4ee5\u901a\u8fc7\u76f8\u540c\u7684\u65b9\u5f0f\u8fdb\u884c\u9012\u5f52\u5212\u5206\uff0c\u76f4\u81f3\u8fbe\u5230\u6700\u5c0f\u5b50\u95ee\u9898 \\(f(1)\\) \u3002\u800c \\(f(1)\\) \u7684\u89e3\u662f\u5df2\u77e5\u7684\uff0c\u53ea\u9700\u4e00\u6b21\u79fb\u52a8\u64cd\u4f5c\u5373\u53ef\u3002

    \u56fe 12-14 \u00a0 \u89e3\u51b3\u6c49\u8bfa\u5854\u95ee\u9898\u7684\u5206\u6cbb\u7b56\u7565

    "},{"location":"chapter_divide_and_conquer/hanota_problem/#3","title":"3. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5728\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u58f0\u660e\u4e00\u4e2a\u9012\u5f52\u51fd\u6570 dfs(i, src, buf, tar) \uff0c\u5b83\u7684\u4f5c\u7528\u662f\u5c06\u67f1 src \u9876\u90e8\u7684 \\(i\\) \u4e2a\u5706\u76d8\u501f\u52a9\u7f13\u51b2\u67f1 buf \u79fb\u52a8\u81f3\u76ee\u6807\u67f1 tar \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hanota.py
    def move(src: list[int], tar: list[int]):\n    \"\"\"\u79fb\u52a8\u4e00\u4e2a\u5706\u76d8\"\"\"\n    # \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    pan = src.pop()\n    # \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"\u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i)\"\"\"\n    # \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if i == 1:\n        move(src, tar)\n        return\n    # \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf)\n    # \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar)\n    # \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"\u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898\"\"\"\n    n = len(A)\n    # \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C)\n
    hanota.cpp
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid move(vector<int> &src, vector<int> &tar) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    int pan = src.back();\n    src.pop_back();\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.push_back(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &tar) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid solveHanota(vector<int> &A, vector<int> &B, vector<int> &C) {\n    int n = A.size();\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.java
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid move(List<Integer> src, List<Integer> tar) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    Integer pan = src.remove(src.size() - 1);\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.add(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {\n    int n = A.size();\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.cs
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid Move(List<int> src, List<int> tar) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.Add(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid DFS(int i, List<int> src, List<int> buf, List<int> tar) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    DFS(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    Move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    DFS(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid SolveHanota(List<int> A, List<int> B, List<int> C) {\n    int n = A.Count;\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    DFS(n, A, B, C);\n}\n
    hanota.go
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfunc move(src, tar *list.List) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    pan := src.Back()\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.PushBack(pan.Value)\n    // \u79fb\u9664 src \u9876\u90e8\u5706\u76d8\n    src.Remove(pan)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfsHanota(i-1, src, tar, buf)\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar)\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfsHanota(n, A, B, C)\n}\n
    hanota.swift
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    let pan = src.popLast()!\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.append(pan)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if i == 1 {\n        move(src: &src, tar: &tar)\n        return\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i: i - 1, src: &src, buf: &tar, tar: &buf)\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src: &src, tar: &tar)\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i: i - 1, src: &buf, buf: &src, tar: &tar)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // \u5217\u8868\u5c3e\u90e8\u662f\u67f1\u5b50\u9876\u90e8\n    // \u5c06 src \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(i: n, src: &A, buf: &B, tar: &C)\n}\n
    hanota.js
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfunction move(src, tar) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    const pan = src.pop();\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.push(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfunction dfs(i, src, buf, tar) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.ts
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfunction move(src: number[], tar: number[]): void {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    const pan = src.pop();\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.push(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.dart
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid move(List<int> src, List<int> tar) {\n  // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n  int pan = src.removeLast();\n  // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n  tar.add(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid dfs(int i, List<int> src, List<int> buf, List<int> tar) {\n  // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n  dfs(i - 1, src, tar, buf);\n  // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n  move(src, tar);\n  // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n  dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid solveHanota(List<int> A, List<int> B, List<int> C) {\n  int n = A.length;\n  // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n  dfs(n, A, B, C);\n}\n
    hanota.rs
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfn move_pan(src: &mut Vec<i32>, tar: &mut Vec<i32>) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    let pan = src.remove(src.len() - 1);\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.push(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfn dfs(i: i32, src: &mut Vec<i32>, buf: &mut Vec<i32>, tar: &mut Vec<i32>) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move_pan(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfn solve_hanota(A: &mut Vec<i32>, B: &mut Vec<i32>, C: &mut Vec<i32>) {\n    let n = A.len() as i32;\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.c
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, srcSize, tar, tarSize);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n
    hanota.kt
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfun move(src: MutableList<Int>, tar: MutableList<Int>) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    val pan: Int = src.removeAt(src.size - 1)\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.add(pan)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfun dfs(i: Int, src: MutableList<Int>, buf: MutableList<Int>, tar: MutableList<Int>) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf)\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar)\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfun solveHanota(A: MutableList<Int>, B: MutableList<Int>, C: MutableList<Int>) {\n    val n = A.size\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C)\n}\n
    hanota.rb
    [class]{}-[func]{move}\n\n[class]{}-[func]{dfs}\n\n[class]{}-[func]{solve_hanota}\n
    hanota.zig
    [class]{}-[func]{move}\n\n[class]{}-[func]{dfs}\n\n[class]{}-[func]{solveHanota}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 12-15 \u6240\u793a\uff0c\u6c49\u8bfa\u5854\u95ee\u9898\u5f62\u6210\u4e00\u68f5\u9ad8\u5ea6\u4e3a \\(n\\) \u7684\u9012\u5f52\u6811\uff0c\u6bcf\u4e2a\u8282\u70b9\u4ee3\u8868\u4e00\u4e2a\u5b50\u95ee\u9898\uff0c\u5bf9\u5e94\u4e00\u4e2a\u5f00\u542f\u7684 dfs() \u51fd\u6570\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    \u56fe 12-15 \u00a0 \u6c49\u8bfa\u5854\u95ee\u9898\u7684\u9012\u5f52\u6811

    Quote

    \u6c49\u8bfa\u5854\u95ee\u9898\u6e90\u81ea\u4e00\u4e2a\u53e4\u8001\u7684\u4f20\u8bf4\u3002\u5728\u53e4\u5370\u5ea6\u7684\u4e00\u4e2a\u5bfa\u5e99\u91cc\uff0c\u50e7\u4fa3\u4eec\u6709\u4e09\u6839\u9ad8\u5927\u7684\u94bb\u77f3\u67f1\u5b50\uff0c\u4ee5\u53ca \\(64\\) \u4e2a\u5927\u5c0f\u4e0d\u4e00\u7684\u91d1\u5706\u76d8\u3002\u50e7\u4fa3\u4eec\u4e0d\u65ad\u5730\u79fb\u52a8\u5706\u76d8\uff0c\u4ed6\u4eec\u76f8\u4fe1\u5728\u6700\u540e\u4e00\u4e2a\u5706\u76d8\u88ab\u6b63\u786e\u653e\u7f6e\u7684\u90a3\u4e00\u523b\uff0c\u8fd9\u4e2a\u4e16\u754c\u5c31\u4f1a\u7ed3\u675f\u3002

    \u7136\u800c\uff0c\u5373\u4f7f\u50e7\u4fa3\u4eec\u6bcf\u79d2\u949f\u79fb\u52a8\u4e00\u6b21\uff0c\u603b\u5171\u9700\u8981\u5927\u7ea6 \\(2^{64} \\approx 1.84\u00d710^{19}\\) \u79d2\uff0c\u5408\u7ea6 \\(5850\\) \u4ebf\u5e74\uff0c\u8fdc\u8fdc\u8d85\u8fc7\u4e86\u73b0\u5728\u5bf9\u5b87\u5b99\u5e74\u9f84\u7684\u4f30\u8ba1\u3002\u6240\u4ee5\uff0c\u5018\u82e5\u8fd9\u4e2a\u4f20\u8bf4\u662f\u771f\u7684\uff0c\u6211\u4eec\u5e94\u8be5\u4e0d\u9700\u8981\u62c5\u5fc3\u4e16\u754c\u672b\u65e5\u7684\u5230\u6765\u3002

    "},{"location":"chapter_divide_and_conquer/summary/","title":"12.5 \u00a0 \u5c0f\u7ed3","text":"
    • \u5206\u6cbb\u662f\u4e00\u79cd\u5e38\u89c1\u7684\u7b97\u6cd5\u8bbe\u8ba1\u7b56\u7565\uff0c\u5305\u62ec\u5206\uff08\u5212\u5206\uff09\u548c\u6cbb\uff08\u5408\u5e76\uff09\u4e24\u4e2a\u9636\u6bb5\uff0c\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u5b9e\u73b0\u3002
    • \u5224\u65ad\u662f\u5426\u662f\u5206\u6cbb\u7b97\u6cd5\u95ee\u9898\u7684\u4f9d\u636e\u5305\u62ec\uff1a\u95ee\u9898\u80fd\u5426\u5206\u89e3\u3001\u5b50\u95ee\u9898\u662f\u5426\u72ec\u7acb\u3001\u5b50\u95ee\u9898\u80fd\u5426\u5408\u5e76\u3002
    • \u5f52\u5e76\u6392\u5e8f\u662f\u5206\u6cbb\u7b56\u7565\u7684\u5178\u578b\u5e94\u7528\uff0c\u5176\u9012\u5f52\u5730\u5c06\u6570\u7ec4\u5212\u5206\u4e3a\u7b49\u957f\u7684\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u76f4\u5230\u53ea\u5269\u4e00\u4e2a\u5143\u7d20\u65f6\u5f00\u59cb\u9010\u5c42\u5408\u5e76\uff0c\u4ece\u800c\u5b8c\u6210\u6392\u5e8f\u3002
    • \u5f15\u5165\u5206\u6cbb\u7b56\u7565\u5f80\u5f80\u53ef\u4ee5\u63d0\u5347\u7b97\u6cd5\u6548\u7387\u3002\u4e00\u65b9\u9762\uff0c\u5206\u6cbb\u7b56\u7565\u51cf\u5c11\u4e86\u64cd\u4f5c\u6570\u91cf\uff1b\u53e6\u4e00\u65b9\u9762\uff0c\u5206\u6cbb\u540e\u6709\u5229\u4e8e\u7cfb\u7edf\u7684\u5e76\u884c\u4f18\u5316\u3002
    • \u5206\u6cbb\u65e2\u53ef\u4ee5\u89e3\u51b3\u8bb8\u591a\u7b97\u6cd5\u95ee\u9898\uff0c\u4e5f\u5e7f\u6cdb\u5e94\u7528\u4e8e\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u8bbe\u8ba1\u4e2d\uff0c\u5904\u5904\u53ef\u89c1\u5176\u8eab\u5f71\u3002
    • \u76f8\u8f83\u4e8e\u66b4\u529b\u641c\u7d22\uff0c\u81ea\u9002\u5e94\u641c\u7d22\u6548\u7387\u66f4\u9ad8\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u7684\u641c\u7d22\u7b97\u6cd5\u901a\u5e38\u662f\u57fa\u4e8e\u5206\u6cbb\u7b56\u7565\u5b9e\u73b0\u7684\u3002
    • \u4e8c\u5206\u67e5\u627e\u662f\u5206\u6cbb\u7b56\u7565\u7684\u53e6\u4e00\u4e2a\u5178\u578b\u5e94\u7528\uff0c\u5b83\u4e0d\u5305\u542b\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u8fdb\u884c\u5408\u5e76\u7684\u6b65\u9aa4\u3002\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u9012\u5f52\u5206\u6cbb\u5b9e\u73b0\u4e8c\u5206\u67e5\u627e\u3002
    • \u5728\u6784\u5efa\u4e8c\u53c9\u6811\u7684\u95ee\u9898\u4e2d\uff0c\u6784\u5efa\u6811\uff08\u539f\u95ee\u9898\uff09\u53ef\u4ee5\u5212\u5206\u4e3a\u6784\u5efa\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\uff08\u5b50\u95ee\u9898\uff09\uff0c\u8fd9\u53ef\u4ee5\u901a\u8fc7\u5212\u5206\u524d\u5e8f\u904d\u5386\u548c\u4e2d\u5e8f\u904d\u5386\u7684\u7d22\u5f15\u533a\u95f4\u6765\u5b9e\u73b0\u3002
    • \u5728\u6c49\u8bfa\u5854\u95ee\u9898\u4e2d\uff0c\u4e00\u4e2a\u89c4\u6a21\u4e3a \\(n\\) \u7684\u95ee\u9898\u53ef\u4ee5\u5212\u5206\u4e3a\u4e24\u4e2a\u89c4\u6a21\u4e3a \\(n-1\\) \u7684\u5b50\u95ee\u9898\u548c\u4e00\u4e2a\u89c4\u6a21\u4e3a \\(1\\) \u7684\u5b50\u95ee\u9898\u3002\u6309\u987a\u5e8f\u89e3\u51b3\u8fd9\u4e09\u4e2a\u5b50\u95ee\u9898\u540e\uff0c\u539f\u95ee\u9898\u968f\u4e4b\u5f97\u5230\u89e3\u51b3\u3002
    "},{"location":"chapter_dynamic_programming/","title":"\u7b2c 14 \u7ae0 \u00a0 \u52a8\u6001\u89c4\u5212","text":"

    Abstract

    \u5c0f\u6eaa\u6c47\u5165\u6cb3\u6d41\uff0c\u6c5f\u6cb3\u6c47\u5165\u5927\u6d77\u3002

    \u52a8\u6001\u89c4\u5212\u5c06\u5c0f\u95ee\u9898\u7684\u89e3\u6c47\u96c6\u6210\u5927\u95ee\u9898\u7684\u7b54\u6848\uff0c\u4e00\u6b65\u6b65\u5f15\u9886\u6211\u4eec\u8d70\u5411\u89e3\u51b3\u95ee\u9898\u7684\u5f7c\u5cb8\u3002

    "},{"location":"chapter_dynamic_programming/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 14.1 \u00a0 \u521d\u63a2\u52a8\u6001\u89c4\u5212
    • 14.2 \u00a0 DP \u95ee\u9898\u7279\u6027
    • 14.3 \u00a0 DP \u89e3\u9898\u601d\u8def
    • 14.4 \u00a0 0-1 \u80cc\u5305\u95ee\u9898
    • 14.5 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898
    • 14.6 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898
    • 14.7 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_dynamic_programming/dp_problem_features/","title":"14.2 \u00a0 \u52a8\u6001\u89c4\u5212\u95ee\u9898\u7279\u6027","text":"

    \u5728\u4e0a\u4e00\u8282\u4e2d\uff0c\u6211\u4eec\u5b66\u4e60\u4e86\u52a8\u6001\u89c4\u5212\u662f\u5982\u4f55\u901a\u8fc7\u5b50\u95ee\u9898\u5206\u89e3\u6765\u6c42\u89e3\u539f\u95ee\u9898\u7684\u3002\u5b9e\u9645\u4e0a\uff0c\u5b50\u95ee\u9898\u5206\u89e3\u662f\u4e00\u79cd\u901a\u7528\u7684\u7b97\u6cd5\u601d\u8def\uff0c\u5728\u5206\u6cbb\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u4e2d\u7684\u4fa7\u91cd\u70b9\u4e0d\u540c\u3002

    • \u5206\u6cbb\u7b97\u6cd5\u9012\u5f52\u5730\u5c06\u539f\u95ee\u9898\u5212\u5206\u4e3a\u591a\u4e2a\u76f8\u4e92\u72ec\u7acb\u7684\u5b50\u95ee\u9898\uff0c\u76f4\u81f3\u6700\u5c0f\u5b50\u95ee\u9898\uff0c\u5e76\u5728\u56de\u6eaf\u4e2d\u5408\u5e76\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u6700\u7ec8\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002
    • \u52a8\u6001\u89c4\u5212\u4e5f\u5bf9\u95ee\u9898\u8fdb\u884c\u9012\u5f52\u5206\u89e3\uff0c\u4f46\u4e0e\u5206\u6cbb\u7b97\u6cd5\u7684\u4e3b\u8981\u533a\u522b\u662f\uff0c\u52a8\u6001\u89c4\u5212\u4e2d\u7684\u5b50\u95ee\u9898\u662f\u76f8\u4e92\u4f9d\u8d56\u7684\uff0c\u5728\u5206\u89e3\u8fc7\u7a0b\u4e2d\u4f1a\u51fa\u73b0\u8bb8\u591a\u91cd\u53e0\u5b50\u95ee\u9898\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\u524d\u7684\u5b50\u5e8f\u5217\u770b\u4f5c\u4e00\u4e2a\u5b50\u95ee\u9898\u3002

    \u5b9e\u9645\u4e0a\uff0c\u52a8\u6001\u89c4\u5212\u5e38\u7528\u6765\u6c42\u89e3\u6700\u4f18\u5316\u95ee\u9898\uff0c\u5b83\u4eec\u4e0d\u4ec5\u5305\u542b\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\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/#1421","title":"14.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\uff08\u8d77\u59cb\u70b9\uff09\u3002\u8bf7\u8ba1\u7b97\u6700\u5c11\u9700\u8981\u4ed8\u51fa\u591a\u5c11\u4ee3\u4ef7\u624d\u80fd\u5230\u8fbe\u9876\u90e8\uff1f

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

    \u56fe 14-6 \u00a0 \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\uff1a

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

    \u8fd9\u4fbf\u53ef\u4ee5\u5f15\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\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

    \u672c\u9898\u663e\u7136\u5177\u6709\u6700\u4f18\u5b50\u7ed3\u6784\uff1a\u6211\u4eec\u4ece\u4e24\u4e2a\u5b50\u95ee\u9898\u6700\u4f18\u89e3 \\(dp[i-1]\\) \u548c \\(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

    \u90a3\u4e48\uff0c\u4e0a\u4e00\u8282\u7684\u722c\u697c\u68af\u9898\u76ee\u6709\u6ca1\u6709\u6700\u4f18\u5b50\u7ed3\u6784\u5462\uff1f\u5b83\u7684\u76ee\u6807\u662f\u6c42\u89e3\u65b9\u6848\u6570\u91cf\uff0c\u770b\u4f3c\u662f\u4e00\u4e2a\u8ba1\u6570\u95ee\u9898\uff0c\u4f46\u5982\u679c\u6362\u4e00\u79cd\u95ee\u6cd5\uff1a\u201c\u6c42\u89e3\u6700\u5927\u65b9\u6848\u6570\u91cf\u201d\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\u89e3\u91ca\u65b9\u5f0f\u6bd4\u8f83\u7075\u6d3b\uff0c\u5728\u4e0d\u540c\u95ee\u9898\u4e2d\u4f1a\u6709\u4e0d\u540c\u7684\u542b\u4e49\u3002

    \u6839\u636e\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff0c\u4ee5\u53ca\u521d\u59cb\u72b6\u6001 \\(dp[1] = cost[1]\\) \u548c \\(dp[2] = cost[2]\\) \uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5f97\u5230\u52a8\u6001\u89c4\u5212\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp = [0] * (n + 1)\n    # \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[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\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[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) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    vector<int> dp(n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.java
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[] dp = new int[n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[] dp = new int[n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.go
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a < b {\n            return a\n        }\n        return b\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp := make([]int, n+1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i := 3; i <= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n
    min_cost_climbing_stairs_dp.swift
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc minCostClimbingStairsDP(cost: [Int]) -> Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = Array(repeating: 0, count: n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n
    min_cost_climbing_stairs_dp.js
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = new Array(n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.ts
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction minCostClimbingStairsDP(cost: Array<number>): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = new Array(n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.dart
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(List<int> cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n  List<int> dp = List.filled(n + 1, 0);\n  // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n  for (int i = 3; i <= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n
    min_cost_climbing_stairs_dp.rs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    let mut dp = vec![-1; n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n
    min_cost_climbing_stairs_dp.c
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int *dp = calloc(n + 1, sizeof(int));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    min_cost_climbing_stairs_dp.kt
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    val dp = IntArray(n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (i in 3..n) {\n        dp[i] = (min(dp[i - 1].toDouble(), dp[i - 2].toDouble()) + cost[i]).toInt()\n    }\n    return dp[n]\n}\n
    min_cost_climbing_stairs_dp.rb
    [class]{}-[func]{min_cost_climbing_stairs_dp}\n
    min_cost_climbing_stairs_dp.zig
    // \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212\nfn minCostClimbingStairsDP(comptime cost: []i32) i32 {\n    comptime var n = cost.len - 1;\n    if (n == 1 or n == 2) {\n        return cost[n];\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = [_]i32{-1} ** (n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (3..n + 1) |i| {\n        dp[i] = @min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-7 \u5c55\u793a\u4e86\u4ee5\u4e0a\u4ee3\u7801\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b\u3002

    \u56fe 14-7 \u00a0 \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u672c\u9898\u4e5f\u53ef\u4ee5\u8fdb\u884c\u7a7a\u95f4\u4f18\u5316\uff0c\u5c06\u4e00\u7ef4\u538b\u7f29\u81f3\u96f6\u7ef4\uff0c\u4f7f\u5f97\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n)\\) \u964d\u81f3 \\(O(1)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n
    min_cost_climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(vector<int> &cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.java
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.go
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a < b {\n            return a\n        }\n        return b\n    }\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    a, b := 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\n    for i := 3; i <= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n
    min_cost_climbing_stairs_dp.swift
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -> Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n
    min_cost_climbing_stairs_dp.js
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i <= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.ts
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction minCostClimbingStairsDPComp(cost: Array<number>): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i <= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.dart
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(List<int> cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i <= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n
    min_cost_climbing_stairs_dp.rs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n
    min_cost_climbing_stairs_dp.c
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.kt
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = (min(a.toDouble(), tmp.toDouble()) + cost[i]).toInt()\n        a = tmp\n    }\n    return b\n}\n
    min_cost_climbing_stairs_dp.rb
    [class]{}-[func]{min_cost_climbing_stairs_dp_comp}\n
    min_cost_climbing_stairs_dp.zig
    // \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn minCostClimbingStairsDPComp(cost: []i32) i32 {\n    var n = cost.len - 1;\n    if (n == 1 or n == 2) {\n        return cost[n];\n    }\n    var a = cost[1];\n    var b = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (3..n + 1) |i| {\n        var tmp = b;\n        b = @min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/dp_problem_features/#1422","title":"14.2.2 \u00a0 \u65e0\u540e\u6548\u6027","text":"

    \u65e0\u540e\u6548\u6027\u662f\u52a8\u6001\u89c4\u5212\u80fd\u591f\u6709\u6548\u89e3\u51b3\u95ee\u9898\u7684\u91cd\u8981\u7279\u6027\u4e4b\u4e00\uff0c\u5176\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\u8fc7\u53bb\u7ecf\u5386\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\u987b\u8003\u8651\u72b6\u6001 \\(i\\) \u4e4b\u524d\u7684\u72b6\u6001\uff0c\u5b83\u4eec\u5bf9\u72b6\u6001 \\(i\\) \u7684\u672a\u6765\u6ca1\u6709\u5f71\u54cd\u3002

    \u7136\u800c\uff0c\u5982\u679c\u6211\u4eec\u7ed9\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\uff1f

    \u5982\u56fe 14-8 \u6240\u793a\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

    \u56fe 14-8 \u00a0 \u5e26\u7ea6\u675f\u722c\u5230\u7b2c 3 \u9636\u7684\u65b9\u6848\u6570\u91cf

    \u5728\u8be5\u95ee\u9898\u4e2d\uff0c\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\u8fd9\u610f\u5473\u7740\uff0c\u4e0b\u4e00\u6b65\u9009\u62e9\u4e0d\u80fd\u7531\u5f53\u524d\u72b6\u6001\uff08\u5f53\u524d\u6240\u5728\u697c\u68af\u9636\u6570\uff09\u72ec\u7acb\u51b3\u5b9a\uff0c\u8fd8\u548c\u524d\u4e00\u4e2a\u72b6\u6001\uff08\u4e0a\u4e00\u8f6e\u6240\u5728\u697c\u68af\u9636\u6570\uff09\u6709\u5173\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\u662f\u8df3 \\(1\\) \u9636\u4e0a\u6765\u7684\u201d\u65b9\u6848\uff0c\u800c\u4e3a\u4e86\u6ee1\u8db3\u7ea6\u675f\uff0c\u6211\u4eec\u5c31\u4e0d\u80fd\u5c06 \\(dp[i-1]\\) \u76f4\u63a5\u8ba1\u5165 \\(dp[i]\\) \u4e2d\u3002

    \u4e3a\u6b64\uff0c\u6211\u4eec\u9700\u8981\u6269\u5c55\u72b6\u6001\u5b9a\u4e49\uff1a\u72b6\u6001 \\([i, j]\\) \u8868\u793a\u5904\u5728\u7b2c \\(i\\) \u9636\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\u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u4ece\u4f55\u800c\u6765\u7684\u3002

    • \u5f53\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(1\\) \u9636\u65f6\uff0c\u4e0a\u4e0a\u4e00\u8f6e\u53ea\u80fd\u9009\u62e9\u8df3 \\(2\\) \u9636\uff0c\u5373 \\(dp[i, 1]\\) \u53ea\u80fd\u4ece \\(dp[i-1, 2]\\) \u8f6c\u79fb\u8fc7\u6765\u3002
    • \u5f53\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(2\\) \u9636\u65f6\uff0c\u4e0a\u4e0a\u4e00\u8f6e\u53ef\u9009\u62e9\u8df3 \\(1\\) \u9636\u6216\u8df3 \\(2\\) \u9636\uff0c\u5373 \\(dp[i, 2]\\) \u53ef\u4ee5\u4ece \\(dp[i-2, 1]\\) \u6216 \\(dp[i-2, 2]\\) \u8f6c\u79fb\u8fc7\u6765\u3002

    \u5982\u56fe 14-9 \u6240\u793a\uff0c\u5728\u8be5\u5b9a\u4e49\u4e0b\uff0c\\(dp[i, j]\\) \u8868\u793a\u72b6\u6001 \\([i, j]\\) \u5bf9\u5e94\u7684\u65b9\u6848\u6570\u3002\u6b64\u65f6\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e3a\uff1a

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

    \u56fe 14-9 \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1], dp[1][2] = 1, 0\n    dp[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\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n
    climbing_stairs_constraint_dp.cpp
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    vector<vector<int>> dp(n + 1, vector<int>(3, 0));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.java
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[][] dp = new int[n + 1][3];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.cs
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[,] dp = new int[n + 1, 3];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n
    climbing_stairs_constraint_dp.go
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp := make([][3]int, n+1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i := 3; i <= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n
    climbing_stairs_constraint_dp.swift
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsConstraintDP(n: Int) -> Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n
    climbing_stairs_constraint_dp.js
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = Array.from(new Array(n + 1), () => new Array(3));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.ts
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = Array.from({ length: n + 1 }, () => new Array(3));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.dart
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(3, 0));\n  // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n  for (int i = 3; i <= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.rs
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfn climbing_stairs_constraint_dp(n: usize) -> i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n
    climbing_stairs_constraint_dp.c
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n
    climbing_stairs_constraint_dp.kt
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    val dp = Array(n + 1) { IntArray(3) }\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n
    climbing_stairs_constraint_dp.rb
    [class]{}-[func]{climbing_stairs_constraint_dp}\n
    climbing_stairs_constraint_dp.zig
    // \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\nfn climbingStairsConstraintDP(comptime n: usize) i32 {\n    if (n == 1 or n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = [_][3]i32{ [_]i32{ -1, -1, -1 } } ** (n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (3..n + 1) |i| {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

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

    \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\u5728\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\\)\u3001\\(3\\) \u9636\u4e0a\uff0c\u5219\u4e4b\u540e\u5c31\u4e0d\u80fd\u8df3\u5230\u7b2c \\(4\\)\u3001\\(6\\) \u9636\u4e0a\u3002\u8bf7\u95ee\u6709\u591a\u5c11\u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\uff1f

    \u5728\u8fd9\u4e2a\u95ee\u9898\u4e2d\uff0c\u4e0b\u6b21\u8df3\u8dc3\u4f9d\u8d56\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\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u590d\u6742\u7684\u7ec4\u5408\u4f18\u5316\u95ee\u9898\uff08\u4f8b\u5982\u65c5\u884c\u5546\u95ee\u9898\uff09\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\u5728\u6709\u9650\u65f6\u95f4\u5185\u5f97\u5230\u53ef\u7528\u7684\u5c40\u90e8\u6700\u4f18\u89e3\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","title":"14.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\u3002

    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/#1431","title":"14.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\u9002\u5408\u7528\u52a8\u6001\u89c4\u5212\u6c42\u89e3\u3002\u7136\u800c\uff0c\u6211\u4eec\u5f88\u96be\u4ece\u95ee\u9898\u63cf\u8ff0\u4e2d\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\u52a8\u6001\u89c4\u5212\u95ee\u9898\u8fd8\u6709\u4e00\u4e9b\u5224\u65ad\u7684\u201c\u52a0\u5206\u9879\u201d\u3002

    • \u95ee\u9898\u5305\u542b\u6700\u5927\uff08\u5c0f\uff09\u6216\u6700\u591a\uff08\u5c11\uff09\u7b49\u6700\u4f18\u5316\u63cf\u8ff0\u3002
    • \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\u9012\u63a8\u5173\u7cfb\u3002

    \u76f8\u5e94\u5730\uff0c\u4e5f\u5b58\u5728\u4e00\u4e9b\u201c\u51cf\u5206\u9879\u201d\u3002

    • \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\u201d\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5047\u8bbe\u5b83\u662f\u4e00\u4e2a\u52a8\u6001\u89c4\u5212\u95ee\u9898\uff0c\u5e76\u5728\u6c42\u89e3\u8fc7\u7a0b\u4e2d\u9a8c\u8bc1\u5b83\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432","title":"14.3.2 \u00a0 \u95ee\u9898\u6c42\u89e3\u6b65\u9aa4","text":"

    \u52a8\u6001\u89c4\u5212\u7684\u89e3\u9898\u6d41\u7a0b\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\u201c\u6700\u5c0f\u8def\u5f84\u548c\u201d\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

    \u56fe 14-10 \u5c55\u793a\u4e86\u4e00\u4e2a\u4f8b\u5b50\uff0c\u7ed9\u5b9a\u7f51\u683c\u7684\u6700\u5c0f\u8def\u5f84\u548c\u4e3a \\(13\\) \u3002

    \u56fe 14-10 \u00a0 \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\u8d70\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\u56fe 14-11 \u6240\u793a\u7684\u4e8c\u7ef4 \\(dp\\) \u77e9\u9635\uff0c\u5176\u5c3a\u5bf8\u4e0e\u8f93\u5165\u7f51\u683c \\(grid\\) \u76f8\u540c\u3002

    \u56fe 14-11 \u00a0 \u72b6\u6001\u5b9a\u4e49\u4e0e dp \u8868

    Note

    \u52a8\u6001\u89c4\u5212\u548c\u56de\u6eaf\u8fc7\u7a0b\u53ef\u4ee5\u63cf\u8ff0\u4e3a\u4e00\u4e2a\u51b3\u7b56\u5e8f\u5217\uff0c\u800c\u72b6\u6001\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\u4ece\u672c\u8d28\u4e0a\u770b\uff0c\\(dp\\) \u8868\u662f\u72b6\u6001\u548c\u5b50\u95ee\u9898\u7684\u89e3\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\u4e2d\u8f83\u5c0f\u7684\u90a3\u4e00\u4e2a\u51b3\u5b9a\u3002

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u53ef\u63a8\u51fa\u56fe 14-12 \u6240\u793a\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff1a

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

    \u56fe 14-12 \u00a0 \u6700\u4f18\u5b50\u7ed3\u6784\u4e0e\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    Note

    \u6839\u636e\u5b9a\u4e49\u597d\u7684 \\(dp\\) \u8868\uff0c\u601d\u8003\u539f\u95ee\u9898\u548c\u5b50\u95ee\u9898\u7684\u5173\u7cfb\uff0c\u627e\u51fa\u901a\u8fc7\u5b50\u95ee\u9898\u7684\u6700\u4f18\u89e3\u6765\u6784\u9020\u539f\u95ee\u9898\u7684\u6700\u4f18\u89e3\u7684\u65b9\u6cd5\uff0c\u5373\u6700\u4f18\u5b50\u7ed3\u6784\u3002

    \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\u5904\u5728\u9996\u884c\u7684\u72b6\u6001\u53ea\u80fd\u4ece\u5176\u5de6\u8fb9\u7684\u72b6\u6001\u5f97\u6765\uff0c\u5904\u5728\u9996\u5217\u7684\u72b6\u6001\u53ea\u80fd\u4ece\u5176\u4e0a\u8fb9\u7684\u72b6\u6001\u5f97\u6765\uff0c\u56e0\u6b64\u9996\u884c \\(i = 0\\) \u548c\u9996\u5217 \\(j = 0\\) \u662f\u8fb9\u754c\u6761\u4ef6\u3002

    \u5982\u56fe 14-13 \u6240\u793a\uff0c\u7531\u4e8e\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\u5faa\u73af\u6765\u904d\u5386\u77e9\u9635\uff0c\u5916\u5faa\u73af\u904d\u5386\u5404\u884c\uff0c\u5185\u5faa\u73af\u904d\u5386\u5404\u5217\u3002

    \u56fe 14-13 \u00a0 \u8fb9\u754c\u6761\u4ef6\u4e0e\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    Note

    \u8fb9\u754c\u6761\u4ef6\u5728\u52a8\u6001\u89c4\u5212\u4e2d\u7528\u4e8e\u521d\u59cb\u5316 \\(dp\\) \u8868\uff0c\u5728\u641c\u7d22\u4e2d\u7528\u4e8e\u526a\u679d\u3002

    \u72b6\u6001\u8f6c\u79fb\u987a\u5e8f\u7684\u6838\u5fc3\u662f\u8981\u4fdd\u8bc1\u5728\u8ba1\u7b97\u5f53\u524d\u95ee\u9898\u7684\u89e3\u65f6\uff0c\u6240\u6709\u5b83\u4f9d\u8d56\u7684\u66f4\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\u90fd\u5df2\u7ecf\u88ab\u6b63\u786e\u5730\u8ba1\u7b97\u51fa\u6765\u3002

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u6211\u4eec\u5df2\u7ecf\u53ef\u4ee5\u76f4\u63a5\u5199\u51fa\u52a8\u6001\u89c4\u5212\u4ee3\u7801\u3002\u7136\u800c\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/#1","title":"1. \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\u9012\u5f52\u51fd\u6570\u5305\u62ec\u4ee5\u4e0b\u8981\u7d20\u3002

    • \u9012\u5f52\u53c2\u6570\uff1a\u72b6\u6001 \\([i, j]\\) \u3002
    • \u8fd4\u56de\u503c\uff1a\u4ece \\([0, 0]\\) \u5230 \\([i, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c \\(dp[i, j]\\) \u3002
    • \u7ec8\u6b62\u6761\u4ef6\uff1a\u5f53 \\(i = 0\\) \u4e14 \\(j = 0\\) \u65f6\uff0c\u8fd4\u56de\u4ee3\u4ef7 \\(grid[0, 0]\\) \u3002
    • \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\u3002

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 or j < 0:\n        return inf\n    # \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = 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\n    return min(left, up) + grid[i][j]\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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return 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\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n
    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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return 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\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return Math.min(left, up) + grid[i][j];\n}\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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return 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\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return Math.Min(left, up) + grid[i][j];\n}\n
    min_path_sum.go
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0 && j == 0 {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return math.MaxInt\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n
    min_path_sum.swift
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -> Int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return .max\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return min(left, up) + grid[i][j]\n}\n
    min_path_sum.js
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfunction minPathSumDFS(grid, i, j) {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i === 0 && j === 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Infinity;\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return Math.min(left, up) + grid[i][j];\n}\n
    min_path_sum.ts
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfunction minPathSumDFS(\n    grid: Array<Array<number>>,\n    i: number,\n    j: number\n): number {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i === 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Infinity;\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return Math.min(left, up) + grid[i][j];\n}\n
    min_path_sum.dart
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(List<List<int>> grid, int i, int j) {\n  // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n  if (i == 0 && j == 0) {\n    return grid[0][0];\n  }\n  // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n  if (i < 0 || j < 0) {\n    // \u5728 Dart \u4e2d\uff0cint \u7c7b\u578b\u662f\u56fa\u5b9a\u8303\u56f4\u7684\u6574\u6570\uff0c\u4e0d\u5b58\u5728\u8868\u793a\u201c\u65e0\u7a77\u5927\u201d\u7684\u503c\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n  return min(left, up) + grid[i][j];\n}\n
    min_path_sum.rs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfn min_path_sum_dfs(grid: &Vec<Vec<i32>>, i: i32, j: i32) -> i32 {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0 && j == 0 {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return i32::MAX;\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = 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\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n
    min_path_sum.c
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return 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\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n
    min_path_sum.kt
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfun minPathSumDFS(\n    grid: Array<Array<Int>>,\n    i: Int,\n    j: Int\n): Int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 && j == 0) {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Int.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\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return (min(left.toDouble(), up.toDouble()) + grid[i][j]).toInt()\n}\n
    min_path_sum.rb
    [class]{}-[func]{min_path_sum_dfs}\n
    min_path_sum.zig
    // \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22\nfn minPathSumDFS(grid: anytype, i: i32, j: i32) i32 {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 and j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 or j < 0) {\n        return std.math.maxInt(i32);\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    var up = minPathSumDFS(grid, i - 1, j);\n    var left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return @min(left, up) + grid[@as(usize, @intCast(i))][@as(usize, @intCast(j))];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-14 \u7ed9\u51fa\u4e86\u4ee5 \\(dp[2, 1]\\) \u4e3a\u6839\u8282\u70b9\u7684\u9012\u5f52\u6811\uff0c\u5176\u4e2d\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

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u9020\u6210\u91cd\u53e0\u5b50\u95ee\u9898\u7684\u539f\u56e0\u4e3a\uff1a\u5b58\u5728\u591a\u6761\u8def\u5f84\u53ef\u4ee5\u4ece\u5de6\u4e0a\u89d2\u5230\u8fbe\u67d0\u4e00\u5355\u5143\u683c\u3002

    \u56fe 14-14 \u00a0 \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\uff0c\u56e0\u6b64\u5b9e\u9645\u7684\u8def\u5f84\u6570\u91cf\u4f1a\u5c11\u4e00\u4e9b\u3002

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

    \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\u5e76\u5c06\u91cd\u53e0\u5b50\u95ee\u9898\u8fdb\u884c\u526a\u679d\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig min_path_sum.py
    def min_path_sum_dfs_mem(\n    grid: 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\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 or j < 0:\n        return inf\n    # \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = 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\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return INT_MAX;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = 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\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n
    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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Integer.MAX_VALUE;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = 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\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return int.MaxValue;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = 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\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n
    min_path_sum.go
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0 && j == 0 {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return math.MaxInt\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := 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\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n
    min_path_sum.swift
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -> Int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return .max\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    let up = minPathSumDFSMem(grid: grid, mem: &mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &mem, i: i, j: j - 1)\n    // \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n
    min_path_sum.js
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i === 0 && j === 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Infinity;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = 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\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n
    min_path_sum.ts
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction minPathSumDFSMem(\n    grid: Array<Array<number>>,\n    mem: Array<Array<number>>,\n    i: number,\n    j: number\n): number {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i === 0 && j === 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Infinity;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = 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\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n
    min_path_sum.dart
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(List<List<int>> grid, List<List<int>> mem, int i, int j) {\n  // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n  if (i == 0 && j == 0) {\n    return grid[0][0];\n  }\n  // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n  if (i < 0 || j < 0) {\n    // \u5728 Dart \u4e2d\uff0cint \u7c7b\u578b\u662f\u56fa\u5b9a\u8303\u56f4\u7684\u6574\u6570\uff0c\u4e0d\u5b58\u5728\u8868\u793a\u201c\u65e0\u7a77\u5927\u201d\u7684\u503c\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = 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\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n
    min_path_sum.rs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfn min_path_sum_dfs_mem(grid: &Vec<Vec<i32>>, mem: &mut Vec<Vec<i32>>, i: i32, j: i32) -> i32 {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0 && j == 0 {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return i32::MAX;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = 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\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n
    min_path_sum.c
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return INT_MAX;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = 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\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n
    min_path_sum.kt
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfun minPathSumDFSMem(\n    grid: Array<Array<Int>>,\n    mem: Array<Array<Int>>,\n    i: Int,\n    j: Int\n): Int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 && j == 0) {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Int.MAX_VALUE\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = 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\n    mem[i][j] = (min(left.toDouble(), up.toDouble()) + grid[i][j]).toInt()\n    return mem[i][j]\n}\n
    min_path_sum.rb
    [class]{}-[func]{min_path_sum_dfs_mem}\n
    min_path_sum.zig
    // \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\nfn minPathSumDFSMem(grid: anytype, mem: anytype, i: i32, j: i32) i32 {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 and j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 or j < 0) {\n        return std.math.maxInt(i32);\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))] != -1) {\n        return mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))];\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    var up = minPathSumDFSMem(grid, mem, i - 1, j);\n    var left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    // \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))] = @min(left, up) + grid[@as(usize, @intCast(i))][@as(usize, @intCast(j))];\n    return mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 14-15 \u6240\u793a\uff0c\u5728\u5f15\u5165\u8bb0\u5fc6\u5316\u540e\uff0c\u6240\u6709\u5b50\u95ee\u9898\u7684\u89e3\u53ea\u9700\u8ba1\u7b97\u4e00\u6b21\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u72b6\u6001\u603b\u6570\uff0c\u5373\u7f51\u683c\u5c3a\u5bf8 \\(O(nm)\\) \u3002

    \u56fe 14-15 \u00a0 \u8bb0\u5fc6\u5316\u641c\u7d22\u9012\u5f52\u6811

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

    \u57fa\u4e8e\u8fed\u4ee3\u5b9e\u73b0\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    n, m = len(grid), len(grid[0])\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(vector<vector<int>> &grid) {\n    int n = grid.size(), m = grid[0].size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n, vector<int>(m));\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (int i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i < n; i++) {\n        for (int j = 1; j < m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (int i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i < n; i++) {\n        for (int j = 1; j < m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (int i = 1; i < n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i < n; i++) {\n        for (int j = 1; j < m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n
    min_path_sum.go
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n)\n    for i := 0; i < n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j := 1; j < m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for i := 1; i < n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i < n; i++ {\n        for j := 1; j < m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n
    min_path_sum.swift
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc minPathSumDP(grid: [[Int]]) -> Int {\n    let n = grid.count\n    let m = grid[0].count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in 1 ..< m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for i in 1 ..< n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1 ..< n {\n        for j in 1 ..< m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n
    min_path_sum.js
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n }, () =>\n        Array.from({ length: m }, () => 0)\n    );\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (let j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (let i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i < n; i++) {\n        for (let j = 1; j < m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    min_path_sum.ts
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction minPathSumDP(grid: Array<Array<number>>): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n }, () =>\n        Array.from({ length: m }, () => 0)\n    );\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (let j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (let i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i < n; i++) {\n        for (let j: number = 1; j < m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    min_path_sum.dart
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(List<List<int>> grid) {\n  int n = grid.length, m = grid[0].length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n, (i) => List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n  for (int j = 1; j < m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n  for (int i = 1; i < n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n  for (int i = 1; i < n; i++) {\n    for (int j = 1; j < m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n
    min_path_sum.rs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfn min_path_sum_dp(grid: &Vec<Vec<i32>>) -> i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n
    min_path_sum.c
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i < n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (int i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i < n; i++) {\n        for (int j = 1; j < m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i < n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n
    min_path_sum.kt
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfun minPathSumDP(grid: Array<Array<Int>>): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (j in 1..<m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (i in 1..<n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (i in 1..<n) {\n        for (j in 1..<m) {\n            dp[i][j] =\n                (min(dp[i][j - 1].toDouble(), dp[i - 1][j].toDouble()) + grid[i][j]).toInt()\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n
    min_path_sum.rb
    [class]{}-[func]{min_path_sum_dp}\n
    min_path_sum.zig
    // \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212\nfn minPathSumDP(comptime grid: anytype) i32 {\n    comptime var n = grid.len;\n    comptime var m = grid[0].len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][m]i32{[_]i32{0} ** m} ** n;\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (1..m) |j| {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (1..n) |i| {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (1..n) |i| {\n        for (1..m) |j| {\n            dp[i][j] = @min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-16 \u5c55\u793a\u4e86\u6700\u5c0f\u8def\u5f84\u548c\u7684\u72b6\u6001\u8f6c\u79fb\u8fc7\u7a0b\uff0c\u5176\u904d\u5386\u4e86\u6574\u4e2a\u7f51\u683c\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nm)\\) \u3002

    \u6570\u7ec4 dp \u5927\u5c0f\u4e3a \\(n \\times m\\) \uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nm)\\) \u3002

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

    \u56fe 14-16 \u00a0 \u6700\u5c0f\u8def\u5f84\u548c\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4","title":"4. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7531\u4e8e\u6bcf\u4e2a\u683c\u5b50\u53ea\u4e0e\u5176\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

    \u8bf7\u6ce8\u610f\uff0c\u56e0\u4e3a\u6570\u7ec4 dp \u53ea\u80fd\u8868\u793a\u4e00\u884c\u7684\u72b6\u6001\uff0c\u6240\u4ee5\u6211\u4eec\u65e0\u6cd5\u63d0\u524d\u521d\u59cb\u5316\u9996\u5217\u72b6\u6001\uff0c\u800c\u662f\u5728\u904d\u5386\u6bcf\u884c\u65f6\u66f4\u65b0\u5b83\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig min_path_sum.py
    def min_path_sum_dp_comp(grid: list[list[int]]) -> int:\n    \"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n, m = len(grid), len(grid[0])\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [0] * m\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in range(1, n):\n        # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0]\n        # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(vector<vector<int>> &grid) {\n    int n = grid.size(), m = grid[0].size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(m);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (int j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j < m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[m];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (int j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j < m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j < m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.go
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, m)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0]\n    for j := 1; j < m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i < n; i++ {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0]\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j := 1; j < m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n
    min_path_sum.swift
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc minPathSumDPComp(grid: [[Int]]) -> Int {\n    let n = grid.count\n    let m = grid[0].count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: 0, count: m)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0]\n    for j in 1 ..< m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in 1 ..< n {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0]\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in 1 ..< m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n
    min_path_sum.js
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = new Array(m);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (let j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (let i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (let j = 1; j < m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.ts
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction minPathSumDPComp(grid: Array<Array<number>>): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = new Array(m);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (let j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (let i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (let j = 1; j < m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.dart
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(List<List<int>> grid) {\n  int n = grid.length, m = grid[0].length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j < m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n  for (int i = 1; i < n; i++) {\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    dp[0] = dp[0] + grid[i][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n    for (int j = 1; j < m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n
    min_path_sum.rs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn min_path_sum_dp_comp(grid: &Vec<Vec<i32>>) -> i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; m];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in 1..n {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n
    min_path_sum.c
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(m, sizeof(int));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (int j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j < m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    min_path_sum.kt
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun minPathSumDPComp(grid: Array<Array<Int>>): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(m)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0]\n    for (j in 1..<m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (i in 1..<n) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0]\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (j in 1..<m) {\n            dp[j] = (min(dp[j - 1].toDouble(), dp[j].toDouble()) + grid[i][j]).toInt()\n        }\n    }\n    return dp[m - 1]\n}\n
    min_path_sum.rb
    [class]{}-[func]{min_path_sum_dp_comp}\n
    min_path_sum.zig
    // \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn minPathSumDPComp(comptime grid: anytype) i32 {\n    comptime var n = grid.len;\n    comptime var m = grid[0].len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** m;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (1..m) |j| {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (1..n) |i| {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        for (1..m) |j| {\n            dp[j] = @min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/edit_distance_problem/","title":"14.6 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898","text":"

    \u7f16\u8f91\u8ddd\u79bb\uff0c\u4e5f\u79f0 Levenshtein \u8ddd\u79bb\uff0c\u6307\u4e24\u4e2a\u5b57\u7b26\u4e32\u4e4b\u95f4\u4e92\u76f8\u8f6c\u6362\u7684\u6700\u5c11\u4fee\u6539\u6b21\u6570\uff0c\u901a\u5e38\u7528\u4e8e\u5728\u4fe1\u606f\u68c0\u7d22\u548c\u81ea\u7136\u8bed\u8a00\u5904\u7406\u4e2d\u5ea6\u91cf\u4e24\u4e2a\u5e8f\u5217\u7684\u76f8\u4f3c\u5ea6\u3002

    Question

    \u8f93\u5165\u4e24\u4e2a\u5b57\u7b26\u4e32 \\(s\\) \u548c \\(t\\) \uff0c\u8fd4\u56de\u5c06 \\(s\\) \u8f6c\u6362\u4e3a \\(t\\) \u6240\u9700\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u3002

    \u4f60\u53ef\u4ee5\u5728\u4e00\u4e2a\u5b57\u7b26\u4e32\u4e2d\u8fdb\u884c\u4e09\u79cd\u7f16\u8f91\u64cd\u4f5c\uff1a\u63d2\u5165\u4e00\u4e2a\u5b57\u7b26\u3001\u5220\u9664\u4e00\u4e2a\u5b57\u7b26\u3001\u5c06\u5b57\u7b26\u66ff\u6362\u4e3a\u4efb\u610f\u4e00\u4e2a\u5b57\u7b26\u3002

    \u5982\u56fe 14-27 \u6240\u793a\uff0c\u5c06 kitten \u8f6c\u6362\u4e3a sitting \u9700\u8981\u7f16\u8f91 3 \u6b65\uff0c\u5305\u62ec 2 \u6b21\u66ff\u6362\u64cd\u4f5c\u4e0e 1 \u6b21\u6dfb\u52a0\u64cd\u4f5c\uff1b\u5c06 hello \u8f6c\u6362\u4e3a algo \u9700\u8981 3 \u6b65\uff0c\u5305\u62ec 2 \u6b21\u66ff\u6362\u64cd\u4f5c\u548c 1 \u6b21\u5220\u9664\u64cd\u4f5c\u3002

    \u56fe 14-27 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u7684\u793a\u4f8b\u6570\u636e

    \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898\u53ef\u4ee5\u5f88\u81ea\u7136\u5730\u7528\u51b3\u7b56\u6811\u6a21\u578b\u6765\u89e3\u91ca\u3002\u5b57\u7b26\u4e32\u5bf9\u5e94\u6811\u8282\u70b9\uff0c\u4e00\u8f6e\u51b3\u7b56\uff08\u4e00\u6b21\u7f16\u8f91\u64cd\u4f5c\uff09\u5bf9\u5e94\u6811\u7684\u4e00\u6761\u8fb9\u3002

    \u5982\u56fe 14-28 \u6240\u793a\uff0c\u5728\u4e0d\u9650\u5236\u64cd\u4f5c\u7684\u60c5\u51b5\u4e0b\uff0c\u6bcf\u4e2a\u8282\u70b9\u90fd\u53ef\u4ee5\u6d3e\u751f\u51fa\u8bb8\u591a\u6761\u8fb9\uff0c\u6bcf\u6761\u8fb9\u5bf9\u5e94\u4e00\u79cd\u64cd\u4f5c\uff0c\u8fd9\u610f\u5473\u7740\u4ece hello \u8f6c\u6362\u5230 algo \u6709\u8bb8\u591a\u79cd\u53ef\u80fd\u7684\u8def\u5f84\u3002

    \u4ece\u51b3\u7b56\u6811\u7684\u89d2\u5ea6\u770b\uff0c\u672c\u9898\u7684\u76ee\u6807\u662f\u6c42\u89e3\u8282\u70b9 hello \u548c\u8282\u70b9 algo \u4e4b\u95f4\u7684\u6700\u77ed\u8def\u5f84\u3002

    \u56fe 14-28 \u00a0 \u57fa\u4e8e\u51b3\u7b56\u6811\u6a21\u578b\u8868\u793a\u7f16\u8f91\u8ddd\u79bb\u95ee\u9898

    "},{"location":"chapter_dynamic_programming/edit_distance_problem/#1","title":"1. \u00a0 \u52a8\u6001\u89c4\u5212\u601d\u8def","text":"

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

    \u6bcf\u4e00\u8f6e\u7684\u51b3\u7b56\u662f\u5bf9\u5b57\u7b26\u4e32 \\(s\\) \u8fdb\u884c\u4e00\u6b21\u7f16\u8f91\u64cd\u4f5c\u3002

    \u6211\u4eec\u5e0c\u671b\u5728\u7f16\u8f91\u64cd\u4f5c\u7684\u8fc7\u7a0b\u4e2d\uff0c\u95ee\u9898\u7684\u89c4\u6a21\u9010\u6e10\u7f29\u5c0f\uff0c\u8fd9\u6837\u624d\u80fd\u6784\u5efa\u5b50\u95ee\u9898\u3002\u8bbe\u5b57\u7b26\u4e32 \\(s\\) \u548c \\(t\\) \u7684\u957f\u5ea6\u5206\u522b\u4e3a \\(n\\) \u548c \\(m\\) \uff0c\u6211\u4eec\u5148\u8003\u8651\u4e24\u5b57\u7b26\u4e32\u5c3e\u90e8\u7684\u5b57\u7b26 \\(s[n-1]\\) \u548c \\(t[m-1]\\) \u3002

    • \u82e5 \\(s[n-1]\\) \u548c \\(t[m-1]\\) \u76f8\u540c\uff0c\u6211\u4eec\u53ef\u4ee5\u8df3\u8fc7\u5b83\u4eec\uff0c\u76f4\u63a5\u8003\u8651 \\(s[n-2]\\) \u548c \\(t[m-2]\\) \u3002
    • \u82e5 \\(s[n-1]\\) \u548c \\(t[m-1]\\) \u4e0d\u540c\uff0c\u6211\u4eec\u9700\u8981\u5bf9 \\(s\\) \u8fdb\u884c\u4e00\u6b21\u7f16\u8f91\uff08\u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\uff09\uff0c\u4f7f\u5f97\u4e24\u5b57\u7b26\u4e32\u5c3e\u90e8\u7684\u5b57\u7b26\u76f8\u540c\uff0c\u4ece\u800c\u53ef\u4ee5\u8df3\u8fc7\u5b83\u4eec\uff0c\u8003\u8651\u89c4\u6a21\u66f4\u5c0f\u7684\u95ee\u9898\u3002

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u6211\u4eec\u5728\u5b57\u7b26\u4e32 \\(s\\) \u4e2d\u8fdb\u884c\u7684\u6bcf\u4e00\u8f6e\u51b3\u7b56\uff08\u7f16\u8f91\u64cd\u4f5c\uff09\uff0c\u90fd\u4f1a\u4f7f\u5f97 \\(s\\) \u548c \\(t\\) \u4e2d\u5269\u4f59\u7684\u5f85\u5339\u914d\u5b57\u7b26\u53d1\u751f\u53d8\u5316\u3002\u56e0\u6b64\uff0c\u72b6\u6001\u4e3a\u5f53\u524d\u5728 \\(s\\) \u548c \\(t\\) \u4e2d\u8003\u8651\u7684\u7b2c \\(i\\) \u548c\u7b2c \\(j\\) \u4e2a\u5b57\u7b26\uff0c\u8bb0\u4e3a \\([i, j]\\) \u3002

    \u72b6\u6001 \\([i, j]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\uff1a\u5c06 \\(s\\) \u7684\u524d \\(i\\) \u4e2a\u5b57\u7b26\u66f4\u6539\u4e3a \\(t\\) \u7684\u524d \\(j\\) \u4e2a\u5b57\u7b26\u6240\u9700\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u3002

    \u81f3\u6b64\uff0c\u5f97\u5230\u4e00\u4e2a\u5c3a\u5bf8\u4e3a \\((i+1) \\times (j+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

    \u8003\u8651\u5b50\u95ee\u9898 \\(dp[i, j]\\) \uff0c\u5176\u5bf9\u5e94\u7684\u4e24\u4e2a\u5b57\u7b26\u4e32\u7684\u5c3e\u90e8\u5b57\u7b26\u4e3a \\(s[i-1]\\) \u548c \\(t[j-1]\\) \uff0c\u53ef\u6839\u636e\u4e0d\u540c\u7f16\u8f91\u64cd\u4f5c\u5206\u4e3a\u56fe 14-29 \u6240\u793a\u7684\u4e09\u79cd\u60c5\u51b5\u3002

    1. \u5728 \\(s[i-1]\\) \u4e4b\u540e\u6dfb\u52a0 \\(t[j-1]\\) \uff0c\u5219\u5269\u4f59\u5b50\u95ee\u9898 \\(dp[i, j-1]\\) \u3002
    2. \u5220\u9664 \\(s[i-1]\\) \uff0c\u5219\u5269\u4f59\u5b50\u95ee\u9898 \\(dp[i-1, j]\\) \u3002
    3. \u5c06 \\(s[i-1]\\) \u66ff\u6362\u4e3a \\(t[j-1]\\) \uff0c\u5219\u5269\u4f59\u5b50\u95ee\u9898 \\(dp[i-1, j-1]\\) \u3002

    \u56fe 14-29 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u7684\u72b6\u6001\u8f6c\u79fb

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u53ef\u5f97\u6700\u4f18\u5b50\u7ed3\u6784\uff1a\\(dp[i, j]\\) \u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u7b49\u4e8e \\(dp[i, j-1]\\)\u3001\\(dp[i-1, j]\\)\u3001\\(dp[i-1, j-1]\\) \u4e09\u8005\u4e2d\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\uff0c\u518d\u52a0\u4e0a\u672c\u6b21\u7684\u7f16\u8f91\u6b65\u6570 \\(1\\) \u3002\u5bf9\u5e94\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e3a\uff1a

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

    \u8bf7\u6ce8\u610f\uff0c\u5f53 \\(s[i-1]\\) \u548c \\(t[j-1]\\) \u76f8\u540c\u65f6\uff0c\u65e0\u987b\u7f16\u8f91\u5f53\u524d\u5b57\u7b26\uff0c\u8fd9\u79cd\u60c5\u51b5\u4e0b\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e3a\uff1a

    \\[ dp[i, j] = dp[i-1, j-1] \\]

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

    \u5f53\u4e24\u5b57\u7b26\u4e32\u90fd\u4e3a\u7a7a\u65f6\uff0c\u7f16\u8f91\u6b65\u6570\u4e3a \\(0\\) \uff0c\u5373 \\(dp[0, 0] = 0\\) \u3002\u5f53 \\(s\\) \u4e3a\u7a7a\u4f46 \\(t\\) \u4e0d\u4e3a\u7a7a\u65f6\uff0c\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u7b49\u4e8e \\(t\\) \u7684\u957f\u5ea6\uff0c\u5373\u9996\u884c \\(dp[0, j] = j\\) \u3002\u5f53 \\(s\\) \u4e0d\u4e3a\u7a7a\u4f46 \\(t\\) \u4e3a\u7a7a\u65f6\uff0c\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u7b49\u4e8e \\(s\\) \u7684\u957f\u5ea6\uff0c\u5373\u9996\u5217 \\(dp[i, 0] = i\\) \u3002

    \u89c2\u5bdf\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff0c\u89e3 \\(dp[i, j]\\) \u4f9d\u8d56\u5de6\u65b9\u3001\u4e0a\u65b9\u3001\u5de6\u4e0a\u65b9\u7684\u89e3\uff0c\u56e0\u6b64\u901a\u8fc7\u4e24\u5c42\u5faa\u73af\u6b63\u5e8f\u904d\u5386\u6574\u4e2a \\(dp\\) \u8868\u5373\u53ef\u3002

    "},{"location":"chapter_dynamic_programming/edit_distance_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig edit_distance.py
    def edit_distance_dp(s: str, t: str) -> int:\n    \"\"\"\u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n
    edit_distance.cpp
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    edit_distance.java
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    edit_distance.cs
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int i = 1; i <= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j <= m; j++) {\n        dp[0, j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n
    edit_distance.go
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for i := 1; i <= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j <= m; j++ {\n        dp[0][j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i <= n; i++ {\n        for j := 1; j <= m; j++ {\n            if s[i-1] == t[j-1] {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n
    edit_distance.swift
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc editDistanceDP(s: String, t: String) -> Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n
    edit_distance.js
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (let i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    edit_distance.ts
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: m + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (let i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    edit_distance.dart
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List<List<int>> dp = List.generate(n + 1, (_) => List.filled(m + 1, 0));\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n  for (int i = 1; i <= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j <= m; j++) {\n    dp[0][j] = j;\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n  for (int i = 1; i <= n; i++) {\n    for (int j = 1; j <= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n
    edit_distance.rs
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfn edit_distance_dp(s: &str, t: &str) -> i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n
    edit_distance.c
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n
    edit_distance.kt
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] =\n                    (min(\n                        min(dp[i][j - 1].toDouble(), dp[i - 1][j].toDouble()),\n                        dp[i - 1][j - 1].toDouble()\n                    ) + 1).toInt()\n            }\n        }\n    }\n    return dp[n][m]\n}\n
    edit_distance.rb
    [class]{}-[func]{edit_distance_dp}\n
    edit_distance.zig
    // \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212\nfn editDistanceDP(comptime s: []const u8, comptime t: []const u8) i32 {\n    comptime var n = s.len;\n    comptime var m = t.len;\n    var dp = [_][m + 1]i32{[_]i32{0} ** (m + 1)} ** (n + 1);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (1..n + 1) |i| {\n        dp[i][0] = @intCast(i);\n    }\n    for (1..m + 1) |j| {\n        dp[0][j] = @intCast(j);\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (1..n + 1) |i| {\n        for (1..m + 1) |j| {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = @min(@min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 14-30 \u6240\u793a\uff0c\u7f16\u8f91\u8ddd\u79bb\u95ee\u9898\u7684\u72b6\u6001\u8f6c\u79fb\u8fc7\u7a0b\u4e0e\u80cc\u5305\u95ee\u9898\u975e\u5e38\u7c7b\u4f3c\uff0c\u90fd\u53ef\u4ee5\u770b\u4f5c\u586b\u5199\u4e00\u4e2a\u4e8c\u7ef4\u7f51\u683c\u7684\u8fc7\u7a0b\u3002

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

    \u56fe 14-30 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    "},{"location":"chapter_dynamic_programming/edit_distance_problem/#3","title":"3. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7531\u4e8e \\(dp[i,j]\\) \u662f\u7531\u4e0a\u65b9 \\(dp[i-1, j]\\)\u3001\u5de6\u65b9 \\(dp[i, j-1]\\)\u3001\u5de6\u4e0a\u65b9 \\(dp[i-1, j-1]\\) \u8f6c\u79fb\u800c\u6765\u7684\uff0c\u800c\u6b63\u5e8f\u904d\u5386\u4f1a\u4e22\u5931\u5de6\u4e0a\u65b9 \\(dp[i-1, j-1]\\) \uff0c\u5012\u5e8f\u904d\u5386\u65e0\u6cd5\u63d0\u524d\u6784\u5efa \\(dp[i, j-1]\\) \uff0c\u56e0\u6b64\u4e24\u79cd\u904d\u5386\u987a\u5e8f\u90fd\u4e0d\u53ef\u53d6\u3002

    \u4e3a\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e00\u4e2a\u53d8\u91cf leftup \u6765\u6682\u5b58\u5de6\u4e0a\u65b9\u7684\u89e3 \\(dp[i-1, j-1]\\) \uff0c\u4ece\u800c\u53ea\u9700\u8003\u8651\u5de6\u65b9\u548c\u4e0a\u65b9\u7684\u89e3\u3002\u6b64\u65f6\u7684\u60c5\u51b5\u4e0e\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u76f8\u540c\uff0c\u53ef\u4f7f\u7528\u6b63\u5e8f\u904d\u5386\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig edit_distance.py
    def edit_distance_dp_comp(s: str, t: str) -> int:\n    \"\"\"\u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in range(1, m + 1):\n        dp[j] = j\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in range(1, n + 1):\n        # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        leftup = dp[0]  # \u6682\u5b58 dp[i-1, j-1]\n        dp[0] += 1\n        # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup\n            else:\n                # \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n    return dp[m]\n
    edit_distance.cpp
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector<int> dp(m + 1, 0);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j <= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.java
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j <= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.cs
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j <= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.go
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j := 1; j <= m; j++ {\n        dp[j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i := 1; i <= n; i++ {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        leftUp := dp[0] // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j := 1; j <= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftUp\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n
    edit_distance.swift
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc editDistanceDPComp(s: String, t: String) -> Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in 1 ... n {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        var leftup = dp[0] // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n
    edit_distance.js
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (let j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (let i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        let leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (let j = 1; j <= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.ts
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (let j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (let i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        let leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (let j = 1; j <= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.dart
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List<int> dp = List.filled(m + 1, 0);\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n  for (int j = 1; j <= m; j++) {\n    dp[j] = j;\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n  for (int i = 1; i <= n; i++) {\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n    dp[0] = i;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n    for (int j = 1; j <= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n        dp[j] = leftup;\n      } else {\n        // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n    }\n  }\n  return dp[m];\n}\n
    edit_distance.rs
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn edit_distance_dp_comp(s: &str, t: &str) -> i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in 1..=n {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        let mut leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i as i32;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    dp[m]\n}\n
    edit_distance.c
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j <= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    int res = dp[m];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    edit_distance.kt
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (i in 1..n) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        var leftup = dp[0] // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = (min(min(dp[j - 1].toDouble(), dp[j].toDouble()), leftup.toDouble()) + 1).toInt()\n            }\n            leftup = temp // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n
    edit_distance.rb
    [class]{}-[func]{edit_distance_dp_comp}\n
    edit_distance.zig
    // \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn editDistanceDPComp(comptime s: []const u8, comptime t: []const u8) i32 {\n    comptime var n = s.len;\n    comptime var m = t.len;\n    var dp = [_]i32{0} ** (m + 1);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (1..m + 1) |j| {\n        dp[j] = @intCast(j);\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (1..n + 1) |i| {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        var leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = @intCast(i);\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (1..m + 1) |j| {\n            var temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = @min(@min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","title":"14.1 \u00a0 \u521d\u63a2\u52a8\u6001\u89c4\u5212","text":"

    \u300c\u52a8\u6001\u89c4\u5212 dynamic programming\u300d\u662f\u4e00\u4e2a\u91cd\u8981\u7684\u7b97\u6cd5\u8303\u5f0f\uff0c\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\uff1f

    \u5982\u56fe 14-1 \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

    \u56fe 14-1 \u00a0 \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if state == n:\n        res[0] += 1\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices:\n        # \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if state + choice > n:\n            continue\n        # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res)\n        # \u56de\u9000\n\ndef climbing_stairs_backtrack(n: int) -> int:\n    \"\"\"\u722c\u697c\u68af\uff1a\u56de\u6eaf\"\"\"\n    choices = [1, 2]  # \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    state = 0  # \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    res = [0]  # \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res)\n    return res[0]\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\n    if (state == n)\n        res[0]++;\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (auto &choice : choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n)\n            continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\n    vector<int> choices = {1, 2}; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    int state = 0;                // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    vector<int> res = {0};        // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n
    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\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (Integer choice : choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n)\n            continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\n    List<Integer> choices = Arrays.asList(1, 2); // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    int state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    List<Integer> res = new ArrayList<>();\n    res.add(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\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\n    if (state == n)\n        res[0]++;\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    foreach (int choice in choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n)\n            continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        Backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint ClimbingStairsBacktrack(int n) {\n    List<int> choices = [1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    int state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    List<int> res = [0]; // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n
    climbing_stairs_backtrack.go
    /* \u56de\u6eaf */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for _, choice := range choices {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if state+choice > n {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state+choice, n, res)\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfunc climbingStairsBacktrack(n int) int {\n    // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    choices := []int{1, 2}\n    // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    state := 0\n    res := make([]int, 1)\n    // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n
    climbing_stairs_backtrack.swift
    /* \u56de\u6eaf */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if state == n {\n        res[0] += 1\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if state + choice > n {\n            continue\n        }\n        backtrack(choices: choices, state: state + choice, n: n, res: &res)\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfunc climbingStairsBacktrack(n: Int) -> Int {\n    let choices = [1, 2] // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    let state = 0 // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    var res: [Int] = []\n    res.append(0) // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices: choices, state: state, n: n, res: &res)\n    return res[0]\n}\n
    climbing_stairs_backtrack.js
    /* \u56de\u6eaf */\nfunction backtrack(choices, state, n, res) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (const choice of choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n) continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    const state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    const res = new Map();\n    res.set(0, 0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n
    climbing_stairs_backtrack.ts
    /* \u56de\u6eaf */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map<0, any>\n): void {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (const choice of choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n) continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    const state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    const res = new Map();\n    res.set(0, 0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n
    climbing_stairs_backtrack.dart
    /* \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\n  if (state == n) {\n    res[0]++;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (int choice in choices) {\n    // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n    if (state + choice > n) continue;\n    // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n    backtrack(choices, state + choice, n, res);\n    // \u56de\u9000\n  }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\n  List<int> choices = [1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n  int state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n  List<int> res = [];\n  res.add(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n
    climbing_stairs_backtrack.rs
    /* \u56de\u6eaf */\nfn backtrack(choices: &[i32], state: i32, n: i32, res: &mut [i32]) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for &choice in choices {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if state + choice > n {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfn climbing_stairs_backtrack(n: usize) -> i32 {\n    let choices = vec![1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    let state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    let mut res = Vec::new();\n    res.push(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(&choices, state, n as i32, &mut res);\n    res[0]\n}\n
    climbing_stairs_backtrack.c
    /* \u56de\u6eaf */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state == n)\n        res[0]++;\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < len; i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n)\n            continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res, len);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    int state = 0;           // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n
    climbing_stairs_backtrack.kt
    /* \u56de\u6eaf */\nfun backtrack(\n    choices: List<Int>,\n    state: Int,\n    n: Int,\n    res: MutableList<Int>\n) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state == n) res[0] = res[0] + 1\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (choice in choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n) continue\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res)\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    val state = 0 // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    val res = ArrayList<Int>()\n    res.add(0) // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n
    climbing_stairs_backtrack.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{climbing_stairs_backtrack}\n
    climbing_stairs_backtrack.zig
    // \u56de\u6eaf\nfn backtrack(choices: []i32, state: i32, n: i32, res: std.ArrayList(i32)) void {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state == n) {\n        res.items[0] = res.items[0] + 1;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (choices) |choice| {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n// \u722c\u697c\u68af\uff1a\u56de\u6eaf\nfn climbingStairsBacktrack(n: usize) !i32 {\n    var choices = [_]i32{ 1, 2 }; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    var state: i32 = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    var res = std.ArrayList(i32).init(std.heap.page_allocator);\n    defer res.deinit();\n    try res.append(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(&choices, state, @intCast(n), res);\n    return res.items[0];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411","title":"14.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\u6c42\u89e3\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

    \u6211\u4eec\u53ef\u4ee5\u5c1d\u8bd5\u4ece\u95ee\u9898\u5206\u89e3\u7684\u89d2\u5ea6\u5206\u6790\u8fd9\u9053\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\uff1a

    \\[ dp[i-1], dp[i-2], \\dots, 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\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u6211\u4eec\u53ea\u80fd\u4ece\u7b2c \\(i -1\\) \u9636\u6216\u7b2c \\(i - 2\\) \u9636\u8fc8\u5411\u7b2c \\(i\\) \u9636\u3002

    \u7531\u6b64\u4fbf\u53ef\u5f97\u51fa\u4e00\u4e2a\u91cd\u8981\u63a8\u8bba\uff1a\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\u3002\u516c\u5f0f\u5982\u4e0b\uff1a

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

    \u8fd9\u610f\u5473\u7740\u5728\u722c\u697c\u68af\u95ee\u9898\u4e2d\uff0c\u5404\u4e2a\u5b50\u95ee\u9898\u4e4b\u95f4\u5b58\u5728\u9012\u63a8\u5173\u7cfb\uff0c\u539f\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u7531\u5b50\u95ee\u9898\u7684\u89e3\u6784\u5efa\u5f97\u6765\u3002\u56fe 14-2 \u5c55\u793a\u4e86\u8be5\u9012\u63a8\u5173\u7cfb\u3002

    \u56fe 14-2 \u00a0 \u65b9\u6848\u6570\u91cf\u9012\u63a8\u5173\u7cfb

    \u6211\u4eec\u53ef\u4ee5\u6839\u636e\u9012\u63a8\u516c\u5f0f\u5f97\u5230\u66b4\u529b\u641c\u7d22\u89e3\u6cd5\u3002\u4ee5 \\(dp[n]\\) \u4e3a\u8d77\u59cb\u70b9\uff0c\u9012\u5f52\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\u662f\u5df2\u77e5\u7684\uff0c\u5373 \\(dp[1] = 1\\)\u3001\\(dp[2] = 2\\) \uff0c\u8868\u793a\u722c\u5230\u7b2c \\(1\\)\u3001\\(2\\) \u9636\u5206\u522b\u6709 \\(1\\)\u3001\\(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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig climbing_stairs_dfs.py
    def dfs(i: int) -> int:\n    \"\"\"\u641c\u7d22\"\"\"\n    # \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -> int:\n    \"\"\"\u722c\u697c\u68af\uff1a\u641c\u7d22\"\"\"\n    return dfs(n)\n
    climbing_stairs_dfs.cpp
    /* \u641c\u7d22 */\nint dfs(int i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.java
    /* \u641c\u7d22 */\nint dfs(int i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.cs
    /* \u641c\u7d22 */\nint DFS(int i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n
    climbing_stairs_dfs.go
    /* \u641c\u7d22 */\nfunc dfs(i int) int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n
    climbing_stairs_dfs.swift
    /* \u641c\u7d22 */\nfunc dfs(i: Int) -> Int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfunc climbingStairsDFS(n: Int) -> Int {\n    dfs(i: n)\n}\n
    climbing_stairs_dfs.js
    /* \u641c\u7d22 */\nfunction dfs(i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.ts
    /* \u641c\u7d22 */\nfunction dfs(i: number): number {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.dart
    /* \u641c\u7d22 */\nint dfs(int i) {\n  // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n
    climbing_stairs_dfs.rs
    /* \u641c\u7d22 */\nfn dfs(i: usize) -> i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfn climbing_stairs_dfs(n: usize) -> i32 {\n    dfs(n)\n}\n
    climbing_stairs_dfs.c
    /* \u641c\u7d22 */\nint dfs(int i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.kt
    /* \u641c\u7d22 */\nfun dfs(i: Int): Int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n
    climbing_stairs_dfs.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{climbing_stairs_dfs}\n
    climbing_stairs_dfs.zig
    // \u641c\u7d22\nfn dfs(i: usize) i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 or i == 2) {\n        return @intCast(i);\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    var count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n// \u722c\u697c\u68af\uff1a\u641c\u7d22\nfn climbingStairsDFS(comptime n: usize) i32 {\n    return dfs(n);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-3 \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\u5c5e\u4e8e\u7206\u70b8\u5f0f\u589e\u957f\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

    \u56fe 14-3 \u00a0 \u722c\u697c\u68af\u5bf9\u5e94\u9012\u5f52\u6811

    \u89c2\u5bdf\u56fe 14-3 \uff0c\u6307\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f\u201c\u91cd\u53e0\u5b50\u95ee\u9898\u201d\u5bfc\u81f4\u7684\u3002\u4f8b\u5982 \\(dp[9]\\) \u88ab\u5206\u89e3\u4e3a \\(dp[8]\\) \u548c \\(dp[7]\\) \uff0c\\(dp[8]\\) \u88ab\u5206\u89e3\u4e3a \\(dp[7]\\) \u548c \\(dp[6]\\) \uff0c\u4e24\u8005\u90fd\u5305\u542b\u5b50\u95ee\u9898 \\(dp[7]\\) \u3002

    \u4ee5\u6b64\u7c7b\u63a8\uff0c\u5b50\u95ee\u9898\u4e2d\u5305\u542b\u66f4\u5c0f\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u5b50\u5b50\u5b59\u5b59\u65e0\u7a77\u5c3d\u4e5f\u3002\u7edd\u5927\u90e8\u5206\u8ba1\u7b97\u8d44\u6e90\u90fd\u6d6a\u8d39\u5728\u8fd9\u4e9b\u91cd\u53e0\u7684\u5b50\u95ee\u9898\u4e0a\u3002

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412","title":"14.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\u4e3a\u6b64\uff0c\u6211\u4eec\u58f0\u660e\u4e00\u4e2a\u6570\u7ec4 mem \u6765\u8bb0\u5f55\u6bcf\u4e2a\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5e76\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u5c06\u91cd\u53e0\u5b50\u95ee\u9898\u526a\u679d\u3002

    1. \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\u3002
    2. \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\u907f\u514d\u91cd\u590d\u8ba1\u7b97\u8be5\u5b50\u95ee\u9898\u3002

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if i == 1 or i == 2:\n        return i\n    # \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # \u8bb0\u5f55 dp[i]\n    mem[i] = count\n    return count\n\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\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\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\n    if (i == 1 || i == 2)\n        return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\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\n    vector<int> mem(n + 1, -1);\n    return dfs(n, mem);\n}\n
    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\n    if (i == 1 || i == 2)\n        return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\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\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\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\n    if (i == 1 || i == 2)\n        return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\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\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n
    climbing_stairs_dfs_mem.go
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc dfsMem(i int, mem []int) int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i\n    }\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n
    climbing_stairs_dfs_mem.swift
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc dfs(i: Int, mem: inout [Int]) -> Int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i\n    }\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &mem) + dfs(i: i - 2, mem: &mem)\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc climbingStairsDFSMem(n: Int) -> Int {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &mem)\n}\n
    climbing_stairs_dfs_mem.js
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction dfs(i, mem) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i === 1 || i === 2) return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.ts
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction dfs(i: number, mem: number[]): number {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i === 1 || i === 2) return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.dart
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, List<int> mem) {\n  // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n  if (i == 1 || i == 2) return i;\n  // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // \u8bb0\u5f55 dp[i]\n  mem[i] = count;\n  return count;\n}\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\n  List<int> mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.rs
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfn dfs(i: usize, mem: &mut [i32]) -> i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    count\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfn climbing_stairs_dfs_mem(n: usize) -> i32 {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &mut mem)\n}\n
    climbing_stairs_dfs_mem.c
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, int *mem) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\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\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i <= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n
    climbing_stairs_dfs_mem.kt
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfun dfs(i: Int, mem: IntArray): Int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2) return i\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    val mem = IntArray(n + 1)\n    Arrays.fill(mem, -1)\n    return dfs(n, mem)\n}\n
    climbing_stairs_dfs_mem.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{climbing_stairs_dfs_mem}\n
    climbing_stairs_dfs_mem.zig
    // \u8bb0\u5fc6\u5316\u641c\u7d22\nfn dfs(i: usize, mem: []i32) i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 or i == 2) {\n        return @intCast(i);\n    }\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1) {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    var count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n// \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\nfn climbingStairsDFSMem(comptime n: usize) i32 {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    var mem = [_]i32{ -1 } ** (n + 1);\n    return dfs(n, &mem);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u89c2\u5bdf\u56fe 14-4 \uff0c\u7ecf\u8fc7\u8bb0\u5fc6\u5316\u5904\u7406\u540e\uff0c\u6240\u6709\u91cd\u53e0\u5b50\u95ee\u9898\u90fd\u53ea\u9700\u8ba1\u7b97\u4e00\u6b21\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(n)\\) \uff0c\u8fd9\u662f\u4e00\u4e2a\u5de8\u5927\u7684\u98de\u8dc3\u3002

    \u56fe 14-4 \u00a0 \u8bb0\u5fc6\u5316\u641c\u7d22\u5bf9\u5e94\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413","title":"14.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\u3002\u4e4b\u540e\uff0c\u901a\u8fc7\u56de\u6eaf\u9010\u5c42\u6536\u96c6\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u6784\u5efa\u51fa\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u4e0e\u4e4b\u76f8\u53cd\uff0c\u52a8\u6001\u89c4\u5212\u662f\u4e00\u79cd\u201c\u4ece\u5e95\u81f3\u9876\u201d\u7684\u65b9\u6cd5\uff1a\u4ece\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\u5f00\u59cb\uff0c\u8fed\u4ee3\u5730\u6784\u5efa\u66f4\u5927\u5b50\u95ee\u9898\u7684\u89e3\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\u53ea\u9700\u4f7f\u7528\u5faa\u73af\u8fed\u4ee3\u5b9e\u73b0\uff0c\u65e0\u987b\u4f7f\u7528\u9012\u5f52\u3002\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u521d\u59cb\u5316\u4e00\u4e2a\u6570\u7ec4 dp \u6765\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5b83\u8d77\u5230\u4e86\u4e0e\u8bb0\u5fc6\u5316\u641c\u7d22\u4e2d\u6570\u7ec4 mem \u76f8\u540c\u7684\u8bb0\u5f55\u4f5c\u7528\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig climbing_stairs_dp.py
    def climbing_stairs_dp(n: int) -> int:\n    \"\"\"\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp = [0] * (n + 1)\n    # \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[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\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n
    climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    vector<int> dp(n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.java
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[] dp = new int[n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[] dp = new int[n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.go
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp := make([]int, n+1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1\n    dp[2] = 2\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i := 3; i <= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n
    climbing_stairs_dp.swift
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsDP(n: Int) -> Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = Array(repeating: 0, count: n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1\n    dp[2] = 2\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n
    climbing_stairs_dp.js
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = new Array(n + 1).fill(-1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.ts
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = new Array(n + 1).fill(-1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.dart
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n  List<int> dp = List.filled(n + 1, 0);\n  // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n  dp[1] = 1;\n  dp[2] = 2;\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n  for (int i = 3; i <= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n
    climbing_stairs_dp.rs
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfn climbing_stairs_dp(n: usize) -> i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    let mut dp = vec![-1; n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n
    climbing_stairs_dp.c
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n
    climbing_stairs_dp.kt
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    val dp = IntArray(n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1\n    dp[2] = 2\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n
    climbing_stairs_dp.rb
    [class]{}-[func]{climbing_stairs_dp}\n
    climbing_stairs_dp.zig
    // \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\nfn climbingStairsDP(comptime n: usize) i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (n == 1 or n == 2) {\n        return @intCast(n);\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = [_]i32{-1} ** (n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (3..n + 1) |i| {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-5 \u6a21\u62df\u4e86\u4ee5\u4e0a\u4ee3\u7801\u7684\u6267\u884c\u8fc7\u7a0b\u3002

    \u56fe 14-5 \u00a0 \u722c\u697c\u68af\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \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\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\uff0c\u722c\u697c\u68af\u95ee\u9898\u7684\u72b6\u6001\u5b9a\u4e49\u4e3a\u5f53\u524d\u6240\u5728\u697c\u68af\u9636\u6570 \\(i\\) \u3002

    \u6839\u636e\u4ee5\u4e0a\u5185\u5bb9\uff0c\u6211\u4eec\u53ef\u4ee5\u603b\u7ed3\u51fa\u52a8\u6001\u89c4\u5212\u7684\u5e38\u7528\u672f\u8bed\u3002

    • \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\u3002
    • \u5c06\u6700\u5c0f\u5b50\u95ee\u9898\u5bf9\u5e94\u7684\u72b6\u6001\uff08\u7b2c \\(1\\) \u9636\u548c\u7b2c \\(2\\) \u9636\u697c\u68af\uff09\u79f0\u4e3a\u300c\u521d\u59cb\u72b6\u6001\u300d\u3002
    • \u5c06\u9012\u63a8\u516c\u5f0f \\(dp[i] = dp[i-1] + dp[i-2]\\) \u79f0\u4e3a\u300c\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u300d\u3002
    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414","title":"14.1.4 \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7ec6\u5fc3\u7684\u8bfb\u8005\u53ef\u80fd\u53d1\u73b0\u4e86\uff0c\u7531\u4e8e \\(dp[i]\\) \u53ea\u4e0e \\(dp[i-1]\\) \u548c \\(dp[i-2]\\) \u6709\u5173\uff0c\u56e0\u6b64\u6211\u4eec\u65e0\u987b\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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig climbing_stairs_dp.py
    def climbing_stairs_dp_comp(n: int) -> int:\n    \"\"\"\u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n
    climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.java
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.go
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i := 3; i <= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n
    climbing_stairs_dp.swift
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsDPComp(n: Int) -> Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n
    climbing_stairs_dp.js
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i <= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.ts
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i <= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.dart
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i <= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n
    climbing_stairs_dp.rs
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn climbing_stairs_dp_comp(n: usize) -> i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n
    climbing_stairs_dp.c
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.kt
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val tmp = b\n        b += a\n        a = tmp\n    }\n    return b\n}\n
    climbing_stairs_dp.rb
    [class]{}-[func]{climbing_stairs_dp_comp}\n
    climbing_stairs_dp.zig
    // \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn climbingStairsDPComp(comptime n: usize) i32 {\n    if (n == 1 or n == 2) {\n        return @intCast(n);\n    }\n    var a: i32 = 1;\n    var b: i32 = 2;\n    for (3..n + 1) |_| {\n        var tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u89c2\u5bdf\u4ee5\u4e0a\u4ee3\u7801\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\u81f3 \\(O(1)\\) \u3002

    \u5728\u52a8\u6001\u89c4\u5212\u95ee\u9898\u4e2d\uff0c\u5f53\u524d\u72b6\u6001\u5f80\u5f80\u4ec5\u4e0e\u524d\u9762\u6709\u9650\u4e2a\u72b6\u6001\u6709\u5173\uff0c\u8fd9\u65f6\u6211\u4eec\u53ef\u4ee5\u53ea\u4fdd\u7559\u5fc5\u8981\u7684\u72b6\u6001\uff0c\u901a\u8fc7\u201c\u964d\u7ef4\u201d\u6765\u8282\u7701\u5185\u5b58\u7a7a\u95f4\u3002\u8fd9\u79cd\u7a7a\u95f4\u4f18\u5316\u6280\u5de7\u88ab\u79f0\u4e3a\u201c\u6eda\u52a8\u53d8\u91cf\u201d\u6216\u201c\u6eda\u52a8\u6570\u7ec4\u201d\u3002

    "},{"location":"chapter_dynamic_programming/knapsack_problem/","title":"14.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\u6c42\u89e3\u6700\u5e38\u89c1\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\u548c\u4e00\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\u3002\u6bcf\u4e2a\u7269\u54c1\u53ea\u80fd\u9009\u62e9\u4e00\u6b21\uff0c\u95ee\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u80fd\u653e\u5165\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002

    \u89c2\u5bdf\u56fe 14-17 \uff0c\u7531\u4e8e\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

    \u56fe 14-17 \u00a0 0-1 \u80cc\u5305\u7684\u793a\u4f8b\u6570\u636e

    \u6211\u4eec\u53ef\u4ee5\u5c06 0-1 \u80cc\u5305\u95ee\u9898\u770b\u4f5c\u4e00\u4e2a\u7531 \\(n\\) \u8f6e\u51b3\u7b56\u7ec4\u6210\u7684\u8fc7\u7a0b\uff0c\u5bf9\u4e8e\u6bcf\u4e2a\u7269\u4f53\u90fd\u6709\u4e0d\u653e\u5165\u548c\u653e\u5165\u4e24\u79cd\u51b3\u7b56\uff0c\u56e0\u6b64\u8be5\u95ee\u9898\u6ee1\u8db3\u51b3\u7b56\u6811\u6a21\u578b\u3002

    \u8be5\u95ee\u9898\u7684\u76ee\u6807\u662f\u6c42\u89e3\u201c\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u80fd\u653e\u5165\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u201d\uff0c\u56e0\u6b64\u8f83\u5927\u6982\u7387\u662f\u4e00\u4e2a\u52a8\u6001\u89c4\u5212\u95ee\u9898\u3002

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

    \u5bf9\u4e8e\u6bcf\u4e2a\u7269\u54c1\u6765\u8bf4\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

    \u5f85\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\uff0c\u53ef\u5206\u4e3a\u4ee5\u4e0b\u4e24\u79cd\u60c5\u51b5\u3002

    • \u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u80cc\u5305\u5bb9\u91cf\u4e0d\u53d8\uff0c\u72b6\u6001\u53d8\u5316\u4e3a \\([i-1, c]\\) \u3002
    • \u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u80cc\u5305\u5bb9\u91cf\u51cf\u5c11 \\(wgt[i-1]\\) \uff0c\u4ef7\u503c\u589e\u52a0 \\(val[i-1]\\) \uff0c\u72b6\u6001\u53d8\u5316\u4e3a \\([i-1, c-wgt[i-1]]\\) \u3002

    \u4e0a\u8ff0\u5206\u6790\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\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\u3002\u7531\u6b64\u53ef\u63a8\u5bfc\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\u9996\u5217 \\(dp[i, 0]\\) \u548c\u9996\u884c \\(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

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u6211\u4eec\u63a5\u4e0b\u6765\u6309\u987a\u5e8f\u5b9e\u73b0\u66b4\u529b\u641c\u7d22\u3001\u8bb0\u5fc6\u5316\u641c\u7d22\u3001\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u3002

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

    \u641c\u7d22\u4ee3\u7801\u5305\u542b\u4ee5\u4e0b\u8981\u7d20\u3002

    • \u9012\u5f52\u53c2\u6570\uff1a\u72b6\u6001 \\([i, c]\\) \u3002
    • \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\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 or c == 0:\n        return 0\n    # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = 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\n    return max(no, yes)\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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int 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\n    return max(no, yes);\n}\n
    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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int 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\n    return Math.max(no, yes);\n}\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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (weight[i - 1] > c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int 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\n    return Math.Max(no, yes);\n}\n
    knapsack.go
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i-1] > c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    no := knapsackDFS(wgt, val, i-1, c)\n    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\n    return int(math.Max(float64(no), float64(yes)))\n}\n
    knapsack.swift
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -> Int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    return max(no, yes)\n}\n
    knapsack.js
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfunction knapsackDFS(wgt, val, i, c) {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const 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\n    return Math.max(no, yes);\n}\n
    knapsack.ts
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfunction knapsackDFS(\n    wgt: Array<number>,\n    val: Array<number>,\n    i: number,\n    c: number\n): number {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const 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\n    return Math.max(no, yes);\n}\n
    knapsack.dart
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nint knapsackDFS(List<int> wgt, List<int> val, int i, int c) {\n  // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n  if (wgt[i - 1] > c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int 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\n  return max(no, yes);\n}\n
    knapsack.rs
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfn knapsack_dfs(wgt: &[i32], val: &[i32], i: usize, c: usize) -> i32 {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    std::cmp::max(no, yes)\n}\n
    knapsack.c
    /* 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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int 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\n    return myMax(no, yes);\n}\n
    knapsack.kt
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfun knapsackDFS(\n    wgt: IntArray,\n    value: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, value, i - 1, c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    val no = knapsackDFS(wgt, value, i - 1, c)\n    val yes = knapsackDFS(wgt, value, i - 1, c - wgt[i - 1]) + value[i - 1]\n    // \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    return max(no.toDouble(), yes.toDouble()).toInt()\n}\n
    knapsack.rb
    [class]{}-[func]{knapsack_dfs}\n
    knapsack.zig
    // 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22\nfn knapsackDFS(wgt: []i32, val: []i32, i: usize, c: usize) i32 {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 or c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    var no = knapsackDFS(wgt, val, i - 1, c);\n    var yes = knapsackDFS(wgt, val, i - 1, c - @as(usize, @intCast(wgt[i - 1]))) + val[i - 1];\n    // \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    return @max(no, yes);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 14-18 \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\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \u3002

    \u89c2\u5bdf\u9012\u5f52\u6811\uff0c\u5bb9\u6613\u53d1\u73b0\u5176\u4e2d\u5b58\u5728\u91cd\u53e0\u5b50\u95ee\u9898\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\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

    \u56fe 14-18 \u00a0 0-1 \u80cc\u5305\u95ee\u9898\u7684\u66b4\u529b\u641c\u7d22\u9012\u5f52\u6811

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

    \u4e3a\u4e86\u4fdd\u8bc1\u91cd\u53e0\u5b50\u95ee\u9898\u53ea\u88ab\u8ba1\u7b97\u4e00\u6b21\uff0c\u6211\u4eec\u501f\u52a9\u8bb0\u5fc6\u5217\u8868 mem \u6765\u8bb0\u5f55\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5176\u4e2d mem[i][c] \u5bf9\u5e94 \\(dp[i, c]\\) \u3002

    \u5f15\u5165\u8bb0\u5fc6\u5316\u4e4b\u540e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u5b50\u95ee\u9898\u6570\u91cf\uff0c\u4e5f\u5c31\u662f \\(O(n \\times cap)\\) \u3002\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig knapsack.py
    def knapsack_dfs_mem(\n    wgt: 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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 or c == 0:\n        return 0\n    # \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c:\n        return 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\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = 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\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int 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\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n
    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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int 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\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (weight[i - 1] > c) {\n        return 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\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int 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\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n
    knapsack.go
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i-1] > c {\n        return 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\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, 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\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n
    knapsack.swift
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -> Int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: 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\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n
    knapsack.js
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        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\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n
    knapsack.ts
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction knapsackDFSMem(\n    wgt: Array<number>,\n    val: Array<number>,\n    mem: Array<Array<number>>,\n    i: number,\n    c: number\n): number {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        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\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n
    knapsack.dart
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(\n  List<int> wgt,\n  List<int> val,\n  List<List<int>> mem,\n  int i,\n  int c,\n) {\n  // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n  if (wgt[i - 1] > c) {\n    return 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\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int 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\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n
    knapsack.rs
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfn knapsack_dfs_mem(wgt: &[i32], val: &[i32], mem: &mut Vec<Vec<i32>>, i: usize, c: usize) -> i32 {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n
    knapsack.c
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, 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\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n
    knapsack.kt
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    value: IntArray,\n    mem: Array<IntArray>,\n    i: Int,\n    c: Int\n): Int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFSMem(wgt, value, mem, i - 1, c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    val no = knapsackDFSMem(wgt, value, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, value, mem, i - 1, c - wgt[i - 1]) + value[i - 1]\n    // \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    mem[i][c] = max(no.toDouble(), yes.toDouble()).toInt()\n    return mem[i][c]\n}\n
    knapsack.rb
    [class]{}-[func]{knapsack_dfs_mem}\n
    knapsack.zig
    // 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\nfn knapsackDFSMem(wgt: []i32, val: []i32, mem: anytype, i: usize, c: usize) i32 {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 or c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    var no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    var yes = knapsackDFSMem(wgt, val, mem, i - 1, c - @as(usize, @intCast(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\n    mem[i][c] = @max(no, yes);\n    return mem[i][c];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-19 \u5c55\u793a\u4e86\u5728\u8bb0\u5fc6\u5316\u641c\u7d22\u4e2d\u88ab\u526a\u6389\u7684\u641c\u7d22\u5206\u652f\u3002

    \u56fe 14-19 \u00a0 0-1 \u80cc\u5305\u95ee\u9898\u7684\u8bb0\u5fc6\u5316\u641c\u7d22\u9012\u5f52\u6811

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

    \u52a8\u6001\u89c4\u5212\u5b9e\u8d28\u4e0a\u5c31\u662f\u5728\u72b6\u6001\u8f6c\u79fb\u4e2d\u586b\u5145 \\(dp\\) \u8868\u7684\u8fc7\u7a0b\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig knapsack.py
    def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:\n    \"\"\"0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(wgt)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] > c:\n                # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {\n    int n = wgt.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n + 1][cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n + 1, cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (weight[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n
    knapsack.go
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        for c := 1; c <= cap; c++ {\n            if wgt[i-1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    knapsack.swift
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -> Int {\n    let n = wgt.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    knapsack.js
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() => Array(cap + 1).fill(0));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    knapsack.ts
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction knapsackDP(\n    wgt: Array<number>,\n    val: Array<number>,\n    cap: number\n): number {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: cap + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    knapsack.dart
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(List<int> wgt, List<int> val, int cap) {\n  int n = wgt.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int c = 1; c <= cap; c++) {\n      if (wgt[i - 1] > c) {\n        // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n        dp[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\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n
    knapsack.rs
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfn knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {\n    let n = wgt.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] > c as i32 {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n
    knapsack.c
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n
    knapsack.kt
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfun knapsackDP(\n    wgt: IntArray,\n    value: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c].toDouble(), (dp[i - 1][c - wgt[i - 1]] + value[i - 1]).toDouble())\n                    .toInt()\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    knapsack.rb
    [class]{}-[func]{knapsack_dp}\n
    knapsack.zig
    // 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\nfn knapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {\n    comptime var n = wgt.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][cap + 1]i32{[_]i32{0} ** (cap + 1)} ** (n + 1);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..cap + 1) |c| {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = @max(dp[i - 1][c], dp[i - 1][c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 14-20 \u6240\u793a\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u90fd\u7531\u6570\u7ec4 dp \u5927\u5c0f\u51b3\u5b9a\uff0c\u5373 \\(O(n \\times cap)\\) \u3002

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

    \u56fe 14-20 \u00a0 0-1 \u80cc\u5305\u95ee\u9898\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    "},{"location":"chapter_dynamic_programming/knapsack_problem/#4","title":"4. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \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)\\) \u964d\u81f3 \\(O(n)\\) \u3002

    \u8fdb\u4e00\u6b65\u601d\u8003\uff0c\u6211\u4eec\u80fd\u5426\u4ec5\u7528\u4e00\u4e2a\u6570\u7ec4\u5b9e\u73b0\u7a7a\u95f4\u4f18\u5316\u5462\uff1f\u89c2\u5bdf\u53ef\u77e5\uff0c\u6bcf\u4e2a\u72b6\u6001\u90fd\u662f\u7531\u6b63\u4e0a\u65b9\u6216\u5de6\u4e0a\u65b9\u7684\u683c\u5b50\u8f6c\u79fb\u8fc7\u6765\u7684\u3002\u5047\u8bbe\u53ea\u6709\u4e00\u4e2a\u6570\u7ec4\uff0c\u5f53\u5f00\u59cb\u904d\u5386\u7b2c \\(i\\) \u884c\u65f6\uff0c\u8be5\u6570\u7ec4\u5b58\u50a8\u7684\u4ecd\u7136\u662f\u7b2c \\(i-1\\) \u884c\u7684\u72b6\u6001\u3002

    • \u5982\u679c\u91c7\u53d6\u6b63\u5e8f\u904d\u5386\uff0c\u90a3\u4e48\u904d\u5386\u5230 \\(dp[i, j]\\) \u65f6\uff0c\u5de6\u4e0a\u65b9 \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) \u503c\u53ef\u80fd\u5df2\u7ecf\u88ab\u8986\u76d6\uff0c\u6b64\u65f6\u5c31\u65e0\u6cd5\u5f97\u5230\u6b63\u786e\u7684\u72b6\u6001\u8f6c\u79fb\u7ed3\u679c\u3002
    • \u5982\u679c\u91c7\u53d6\u5012\u5e8f\u904d\u5386\uff0c\u5219\u4e0d\u4f1a\u53d1\u751f\u8986\u76d6\u95ee\u9898\uff0c\u72b6\u6001\u8f6c\u79fb\u53ef\u4ee5\u6b63\u786e\u8fdb\u884c\u3002

    \u56fe 14-21 \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\u8bf7\u601d\u8003\u6b63\u5e8f\u904d\u5386\u548c\u5012\u5e8f\u904d\u5386\u7684\u533a\u522b\u3002

    <1><2><3><4><5><6>

    \u56fe 14-21 \u00a0 0-1 \u80cc\u5305\u7684\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u5728\u4ee3\u7801\u5b9e\u73b0\u4e2d\uff0c\u6211\u4eec\u4ec5\u9700\u5c06\u6570\u7ec4 dp \u7684\u7b2c\u4e00\u7ef4 \\(i\\) \u76f4\u63a5\u5220\u9664\uff0c\u5e76\u4e14\u628a\u5185\u5faa\u73af\u66f4\u6539\u4e3a\u5012\u5e8f\u904d\u5386\u5373\u53ef\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig knapsack.py
    def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:\n    \"\"\"0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(wgt)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [0] * (cap + 1)\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        # \u5012\u5e8f\u904d\u5386\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] > c:\n                # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {\n    int n = wgt.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(cap + 1, 0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (int c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (int c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (int c = cap; c > 0; c--) {\n            if (weight[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.go
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, cap+1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        // \u5012\u5e8f\u904d\u5386\n        for c := cap; c >= 1; c-- {\n            if wgt[i-1] <= c {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n
    knapsack.swift
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -> Int {\n    let n = wgt.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: 0, count: cap + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        // \u5012\u5e8f\u904d\u5386\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] <= c {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n
    knapsack.js
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array(cap + 1).fill(0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (let c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.ts
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction knapsackDPComp(\n    wgt: Array<number>,\n    val: Array<number>,\n    cap: number\n): number {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array(cap + 1).fill(0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (let c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.dart
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(List<int> wgt, List<int> val, int cap) {\n  int n = wgt.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(cap + 1, 0);\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    // \u5012\u5e8f\u904d\u5386\n    for (int c = cap; c >= 1; c--) {\n      if (wgt[i - 1] <= c) {\n        // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n
    knapsack.rs
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {\n    let n = wgt.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        // \u5012\u5e8f\u904d\u5386\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] <= c as i32 {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n
    knapsack.c
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(cap + 1, sizeof(int));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (int c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    knapsack.kt
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun knapsackDPComp(\n    wgt: IntArray,\n    value: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(cap + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        // \u5012\u5e8f\u904d\u5386\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] =\n                    max(dp[c].toDouble(), (dp[c - wgt[i - 1]] + value[i - 1]).toDouble()).toInt()\n            }\n        }\n    }\n    return dp[cap]\n}\n
    knapsack.rb
    [class]{}-[func]{knapsack_dp_comp}\n
    knapsack.zig
    // 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn knapsackDPComp(wgt: []i32, val: []i32, comptime cap: usize) i32 {\n    var n = wgt.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** (cap + 1);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        // \u5012\u5e8f\u904d\u5386\n        var c = cap;\n        while (c > 0) : (c -= 1) {\n            if (wgt[i - 1] < c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = @max(dp[c], dp[c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/summary/","title":"14.7 \u00a0 \u5c0f\u7ed3","text":"
    • \u52a8\u6001\u89c4\u5212\u5bf9\u95ee\u9898\u8fdb\u884c\u5206\u89e3\uff0c\u5e76\u901a\u8fc7\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\u6765\u89c4\u907f\u91cd\u590d\u8ba1\u7b97\uff0c\u63d0\u9ad8\u8ba1\u7b97\u6548\u7387\u3002
    • \u4e0d\u8003\u8651\u65f6\u95f4\u7684\u524d\u63d0\u4e0b\uff0c\u6240\u6709\u52a8\u6001\u89c4\u5212\u95ee\u9898\u90fd\u53ef\u4ee5\u7528\u56de\u6eaf\uff08\u66b4\u529b\u641c\u7d22\uff09\u8fdb\u884c\u6c42\u89e3\uff0c\u4f46\u9012\u5f52\u6811\u4e2d\u5b58\u5728\u5927\u91cf\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u6548\u7387\u6781\u4f4e\u3002\u901a\u8fc7\u5f15\u5165\u8bb0\u5fc6\u5316\u5217\u8868\uff0c\u53ef\u4ee5\u5b58\u50a8\u6240\u6709\u8ba1\u7b97\u8fc7\u7684\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u4ece\u800c\u4fdd\u8bc1\u91cd\u53e0\u5b50\u95ee\u9898\u53ea\u88ab\u8ba1\u7b97\u4e00\u6b21\u3002
    • \u8bb0\u5fc6\u5316\u641c\u7d22\u662f\u4e00\u79cd\u4ece\u9876\u81f3\u5e95\u7684\u9012\u5f52\u5f0f\u89e3\u6cd5\uff0c\u800c\u4e0e\u4e4b\u5bf9\u5e94\u7684\u52a8\u6001\u89c4\u5212\u662f\u4e00\u79cd\u4ece\u5e95\u81f3\u9876\u7684\u9012\u63a8\u5f0f\u89e3\u6cd5\uff0c\u5176\u5982\u540c\u201c\u586b\u5199\u8868\u683c\u201d\u4e00\u6837\u3002\u7531\u4e8e\u5f53\u524d\u72b6\u6001\u4ec5\u4f9d\u8d56\u67d0\u4e9b\u5c40\u90e8\u72b6\u6001\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u6d88\u9664 \\(dp\\) \u8868\u7684\u4e00\u4e2a\u7ef4\u5ea6\uff0c\u4ece\u800c\u964d\u4f4e\u7a7a\u95f4\u590d\u6742\u5ea6\u3002
    • \u5b50\u95ee\u9898\u5206\u89e3\u662f\u4e00\u79cd\u901a\u7528\u7684\u7b97\u6cd5\u601d\u8def\uff0c\u5728\u5206\u6cbb\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u4e2d\u5177\u6709\u4e0d\u540c\u7684\u6027\u8d28\u3002
    • \u52a8\u6001\u89c4\u5212\u95ee\u9898\u6709\u4e09\u5927\u7279\u6027\uff1a\u91cd\u53e0\u5b50\u95ee\u9898\u3001\u6700\u4f18\u5b50\u7ed3\u6784\u3001\u65e0\u540e\u6548\u6027\u3002
    • \u5982\u679c\u539f\u95ee\u9898\u7684\u6700\u4f18\u89e3\u53ef\u4ee5\u4ece\u5b50\u95ee\u9898\u7684\u6700\u4f18\u89e3\u6784\u5efa\u5f97\u6765\uff0c\u5219\u5b83\u5c31\u5177\u6709\u6700\u4f18\u5b50\u7ed3\u6784\u3002
    • \u65e0\u540e\u6548\u6027\u6307\u5bf9\u4e8e\u4e00\u4e2a\u72b6\u6001\uff0c\u5176\u672a\u6765\u53d1\u5c55\u53ea\u4e0e\u8be5\u72b6\u6001\u6709\u5173\uff0c\u800c\u4e0e\u8fc7\u53bb\u7ecf\u5386\u7684\u6240\u6709\u72b6\u6001\u65e0\u5173\u3002\u8bb8\u591a\u7ec4\u5408\u4f18\u5316\u95ee\u9898\u4e0d\u5177\u6709\u65e0\u540e\u6548\u6027\uff0c\u65e0\u6cd5\u4f7f\u7528\u52a8\u6001\u89c4\u5212\u5feb\u901f\u6c42\u89e3\u3002

    \u80cc\u5305\u95ee\u9898

    • \u80cc\u5305\u95ee\u9898\u662f\u6700\u5178\u578b\u7684\u52a8\u6001\u89c4\u5212\u95ee\u9898\u4e4b\u4e00\uff0c\u5177\u6709 0-1 \u80cc\u5305\u3001\u5b8c\u5168\u80cc\u5305\u3001\u591a\u91cd\u80cc\u5305\u7b49\u53d8\u79cd\u3002
    • 0-1 \u80cc\u5305\u7684\u72b6\u6001\u5b9a\u4e49\u4e3a\u524d \\(i\\) \u4e2a\u7269\u54c1\u5728\u5269\u4f59\u5bb9\u91cf\u4e3a \\(c\\) \u7684\u80cc\u5305\u4e2d\u7684\u6700\u5927\u4ef7\u503c\u3002\u6839\u636e\u4e0d\u653e\u5165\u80cc\u5305\u548c\u653e\u5165\u80cc\u5305\u4e24\u79cd\u51b3\u7b56\uff0c\u53ef\u5f97\u5230\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u5e76\u6784\u5efa\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u3002\u5728\u7a7a\u95f4\u4f18\u5316\u4e2d\uff0c\u7531\u4e8e\u6bcf\u4e2a\u72b6\u6001\u4f9d\u8d56\u6b63\u4e0a\u65b9\u548c\u5de6\u4e0a\u65b9\u7684\u72b6\u6001\uff0c\u56e0\u6b64\u9700\u8981\u5012\u5e8f\u904d\u5386\u5217\u8868\uff0c\u907f\u514d\u5de6\u4e0a\u65b9\u72b6\u6001\u88ab\u8986\u76d6\u3002
    • \u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u6bcf\u79cd\u7269\u54c1\u7684\u9009\u53d6\u6570\u91cf\u65e0\u9650\u5236\uff0c\u56e0\u6b64\u9009\u62e9\u653e\u5165\u7269\u54c1\u7684\u72b6\u6001\u8f6c\u79fb\u4e0e 0-1 \u80cc\u5305\u95ee\u9898\u4e0d\u540c\u3002\u7531\u4e8e\u72b6\u6001\u4f9d\u8d56\u6b63\u4e0a\u65b9\u548c\u6b63\u5de6\u65b9\u7684\u72b6\u6001\uff0c\u56e0\u6b64\u5728\u7a7a\u95f4\u4f18\u5316\u4e2d\u5e94\u5f53\u6b63\u5e8f\u904d\u5386\u3002
    • \u96f6\u94b1\u5151\u6362\u95ee\u9898\u662f\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u4e00\u4e2a\u53d8\u79cd\u3002\u5b83\u4ece\u6c42\u201c\u6700\u5927\u201d\u4ef7\u503c\u53d8\u4e3a\u6c42\u201c\u6700\u5c0f\u201d\u786c\u5e01\u6570\u91cf\uff0c\u56e0\u6b64\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e2d\u7684 \\(\\max()\\) \u5e94\u6539\u4e3a \\(\\min()\\) \u3002\u4ece\u8ffd\u6c42\u201c\u4e0d\u8d85\u8fc7\u201d\u80cc\u5305\u5bb9\u91cf\u5230\u8ffd\u6c42\u201c\u6070\u597d\u201d\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u56e0\u6b64\u4f7f\u7528 \\(amt + 1\\) \u6765\u8868\u793a\u201c\u65e0\u6cd5\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u201d\u7684\u65e0\u6548\u89e3\u3002
    • \u96f6\u94b1\u5151\u6362\u95ee\u9898 II \u4ece\u6c42\u201c\u6700\u5c11\u786c\u5e01\u6570\u91cf\u201d\u6539\u4e3a\u6c42\u201c\u786c\u5e01\u7ec4\u5408\u6570\u91cf\u201d\uff0c\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u76f8\u5e94\u5730\u4ece \\(\\min()\\) \u6539\u4e3a\u6c42\u548c\u8fd0\u7b97\u7b26\u3002

    \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898

    • \u7f16\u8f91\u8ddd\u79bb\uff08Levenshtein \u8ddd\u79bb\uff09\u7528\u4e8e\u8861\u91cf\u4e24\u4e2a\u5b57\u7b26\u4e32\u4e4b\u95f4\u7684\u76f8\u4f3c\u5ea6\uff0c\u5176\u5b9a\u4e49\u4e3a\u4ece\u4e00\u4e2a\u5b57\u7b26\u4e32\u5230\u53e6\u4e00\u4e2a\u5b57\u7b26\u4e32\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\uff0c\u7f16\u8f91\u64cd\u4f5c\u5305\u62ec\u6dfb\u52a0\u3001\u5220\u9664\u3001\u66ff\u6362\u3002
    • \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898\u7684\u72b6\u6001\u5b9a\u4e49\u4e3a\u5c06 \\(s\\) \u7684\u524d \\(i\\) \u4e2a\u5b57\u7b26\u66f4\u6539\u4e3a \\(t\\) \u7684\u524d \\(j\\) \u4e2a\u5b57\u7b26\u6240\u9700\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u3002\u5f53 \\(s[i] \\ne t[j]\\) \u65f6\uff0c\u5177\u6709\u4e09\u79cd\u51b3\u7b56\uff1a\u6dfb\u52a0\u3001\u5220\u9664\u3001\u66ff\u6362\uff0c\u5b83\u4eec\u90fd\u6709\u76f8\u5e94\u7684\u5269\u4f59\u5b50\u95ee\u9898\u3002\u636e\u6b64\u4fbf\u53ef\u4ee5\u627e\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\u4e0e\u6784\u5efa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u3002\u800c\u5f53 \\(s[i] = t[j]\\) \u65f6\uff0c\u65e0\u987b\u7f16\u8f91\u5f53\u524d\u5b57\u7b26\u3002
    • \u5728\u7f16\u8f91\u8ddd\u79bb\u4e2d\uff0c\u72b6\u6001\u4f9d\u8d56\u5176\u6b63\u4e0a\u65b9\u3001\u6b63\u5de6\u65b9\u3001\u5de6\u4e0a\u65b9\u7684\u72b6\u6001\uff0c\u56e0\u6b64\u7a7a\u95f4\u4f18\u5316\u540e\u6b63\u5e8f\u6216\u5012\u5e8f\u904d\u5386\u90fd\u65e0\u6cd5\u6b63\u786e\u5730\u8fdb\u884c\u72b6\u6001\u8f6c\u79fb\u3002\u4e3a\u6b64\uff0c\u6211\u4eec\u5229\u7528\u4e00\u4e2a\u53d8\u91cf\u6682\u5b58\u5de6\u4e0a\u65b9\u72b6\u6001\uff0c\u4ece\u800c\u8f6c\u5316\u5230\u4e0e\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7b49\u4ef7\u7684\u60c5\u51b5\uff0c\u53ef\u4ee5\u5728\u7a7a\u95f4\u4f18\u5316\u540e\u8fdb\u884c\u6b63\u5e8f\u904d\u5386\u3002
    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","title":"14.5 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898","text":"

    \u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u5148\u6c42\u89e3\u53e6\u4e00\u4e2a\u5e38\u89c1\u7684\u80cc\u5305\u95ee\u9898\uff1a\u5b8c\u5168\u80cc\u5305\uff0c\u518d\u4e86\u89e3\u5b83\u7684\u4e00\u79cd\u7279\u4f8b\uff1a\u96f6\u94b1\u5151\u6362\u3002

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451","title":"14.5.1 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898","text":"

    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\u548c\u4e00\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\u3002\u6bcf\u4e2a\u7269\u54c1\u53ef\u4ee5\u91cd\u590d\u9009\u53d6\uff0c\u95ee\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u80fd\u653e\u5165\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002\u793a\u4f8b\u5982\u56fe 14-22 \u6240\u793a\u3002

    \u56fe 14-22 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1","title":"1. \u00a0 \u52a8\u6001\u89c4\u5212\u601d\u8def","text":"

    \u5b8c\u5168\u80cc\u5305\u95ee\u9898\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\u95ee\u9898\u4e2d\uff0c\u6bcf\u79cd\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\u3002
    • \u5728\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u4e2d\uff0c\u6bcf\u79cd\u7269\u54c1\u7684\u6570\u91cf\u662f\u65e0\u9650\u7684\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\u3002

    \u5728\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u89c4\u5b9a\u4e0b\uff0c\u72b6\u6001 \\([i, c]\\) \u7684\u53d8\u5316\u5206\u4e3a\u4e24\u79cd\u60c5\u51b5\u3002

    • \u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u4e0e 0-1 \u80cc\u5305\u95ee\u9898\u76f8\u540c\uff0c\u8f6c\u79fb\u81f3 \\([i-1, c]\\) \u3002
    • \u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u4e0e 0-1 \u80cc\u5305\u95ee\u9898\u4e0d\u540c\uff0c\u8f6c\u79fb\u81f3 \\([i, c-wgt[i-1]]\\) \u3002

    \u4ece\u800c\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]) \\]"},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5bf9\u6bd4\u4e24\u9053\u9898\u76ee\u7684\u4ee3\u7801\uff0c\u72b6\u6001\u8f6c\u79fb\u4e2d\u6709\u4e00\u5904\u4ece \\(i-1\\) \u53d8\u4e3a \\(i\\) \uff0c\u5176\u4f59\u5b8c\u5168\u4e00\u81f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    n = len(wgt)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] > c:\n                # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n
    unbounded_knapsack.cpp
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {\n    int n = wgt.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.java
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n + 1][cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.cs
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n + 1, cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n
    unbounded_knapsack.go
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        for c := 1; c <= cap; c++ {\n            if wgt[i-1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    unbounded_knapsack.swift
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -> Int {\n    let n = wgt.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    unbounded_knapsack.js
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: cap + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.ts
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction unboundedKnapsackDP(\n    wgt: Array<number>,\n    val: Array<number>,\n    cap: number\n): number {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: cap + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.dart
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(List<int> wgt, List<int> val, int cap) {\n  int n = wgt.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int c = 1; c <= cap; c++) {\n      if (wgt[i - 1] > c) {\n        // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n        dp[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\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n
    unbounded_knapsack.rs
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfn unbounded_knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {\n    let n = wgt.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] > c as i32 {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.c
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n
    unbounded_knapsack.kt
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfun unboundedKnapsackDP(\n    wgt: IntArray,\n    value: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c].toDouble(), (dp[i][c - wgt[i - 1]] + value[i - 1]).toDouble())\n                    .toInt()\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    unbounded_knapsack.rb
    [class]{}-[func]{unbounded_knapsack_dp}\n
    unbounded_knapsack.zig
    // \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\nfn unboundedKnapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {\n    comptime var n = wgt.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][cap + 1]i32{[_]i32{0} ** (cap + 1)} ** (n + 1);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..cap + 1) |c| {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = @max(dp[i - 1][c], dp[i][c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3","title":"3. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7531\u4e8e\u5f53\u524d\u72b6\u6001\u662f\u4ece\u5de6\u8fb9\u548c\u4e0a\u8fb9\u7684\u72b6\u6001\u8f6c\u79fb\u800c\u6765\u7684\uff0c\u56e0\u6b64\u7a7a\u95f4\u4f18\u5316\u540e\u5e94\u8be5\u5bf9 \\(dp\\) \u8868\u4e2d\u7684\u6bcf\u4e00\u884c\u8fdb\u884c\u6b63\u5e8f\u904d\u5386\u3002

    \u8fd9\u4e2a\u904d\u5386\u987a\u5e8f\u4e0e 0-1 \u80cc\u5305\u6b63\u597d\u76f8\u53cd\u3002\u8bf7\u501f\u52a9\u56fe 14-23 \u6765\u7406\u89e3\u4e24\u8005\u7684\u533a\u522b\u3002

    <1><2><3><4><5><6>

    \u56fe 14-23 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898\u5728\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u4ee3\u7801\u5b9e\u73b0\u6bd4\u8f83\u7b80\u5355\uff0c\u4ec5\u9700\u5c06\u6570\u7ec4 dp \u7684\u7b2c\u4e00\u7ef4\u5220\u9664\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig unbounded_knapsack.py
    def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:\n    \"\"\"\u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(wgt)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [0] * (cap + 1)\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        # \u6b63\u5e8f\u904d\u5386\n        for c in range(1, cap + 1):\n            if wgt[i - 1] > c:\n                # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n
    unbounded_knapsack.cpp
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {\n    int n = wgt.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(cap + 1, 0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.java
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.cs
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.go
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, cap+1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        for c := 1; c <= cap; c++ {\n            if wgt[i-1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n
    unbounded_knapsack.swift
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -> Int {\n    let n = wgt.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: 0, count: cap + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n
    unbounded_knapsack.js
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: cap + 1 }, () => 0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.ts
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction unboundedKnapsackDPComp(\n    wgt: Array<number>,\n    val: Array<number>,\n    cap: number\n): number {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: cap + 1 }, () => 0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.dart
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(List<int> wgt, List<int> val, int cap) {\n  int n = wgt.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(cap + 1, 0);\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int c = 1; c <= cap; c++) {\n      if (wgt[i - 1] > c) {\n        // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n        dp[c] = dp[c];\n      } else {\n        // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n
    unbounded_knapsack.rs
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn unbounded_knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {\n    let n = wgt.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] > c as i32 {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n
    unbounded_knapsack.c
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(cap + 1, sizeof(int));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    unbounded_knapsack.kt
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    value: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(cap + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] =\n                    max(dp[c].toDouble(), (dp[c - wgt[i - 1]] + value[i - 1]).toDouble()).toInt()\n            }\n        }\n    }\n    return dp[cap]\n}\n
    unbounded_knapsack.rb
    [class]{}-[func]{unbounded_knapsack_dp_comp}\n
    unbounded_knapsack.zig
    // \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn unboundedKnapsackDPComp(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {\n    comptime var n = wgt.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** (cap + 1);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..cap + 1) |c| {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = @max(dp[c], dp[c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452","title":"14.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\u53d8\u79cd\uff0c\u4f8b\u5982\u96f6\u94b1\u5151\u6362\u95ee\u9898\u3002

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u786c\u5e01\uff0c\u7b2c \\(i\\) \u79cd\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\u80fd\u591f\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u7684\u6700\u5c11\u786c\u5e01\u6570\u91cf\u3002\u5982\u679c\u65e0\u6cd5\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002\u793a\u4f8b\u5982\u56fe 14-24 \u6240\u793a\u3002

    \u56fe 14-24 \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_1","title":"1. \u00a0 \u52a8\u6001\u89c4\u5212\u601d\u8def","text":"

    \u96f6\u94b1\u5151\u6362\u53ef\u4ee5\u770b\u4f5c\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\u3002

    • \u4e24\u9053\u9898\u53ef\u4ee5\u76f8\u4e92\u8f6c\u6362\uff0c\u201c\u7269\u54c1\u201d\u5bf9\u5e94\u201c\u786c\u5e01\u201d\u3001\u201c\u7269\u54c1\u91cd\u91cf\u201d\u5bf9\u5e94\u201c\u786c\u5e01\u9762\u503c\u201d\u3001\u201c\u80cc\u5305\u5bb9\u91cf\u201d\u5bf9\u5e94\u201c\u76ee\u6807\u91d1\u989d\u201d\u3002
    • \u4f18\u5316\u76ee\u6807\u76f8\u53cd\uff0c\u5b8c\u5168\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\u3002
    • \u5b8c\u5168\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\u3002

    \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\\) \u79cd\u786c\u5e01\u80fd\u591f\u51d1\u51fa\u91d1\u989d \\(a\\) \u7684\u6700\u5c11\u786c\u5e01\u6570\u91cf\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

    \u672c\u9898\u4e0e\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u5b58\u5728\u4ee5\u4e0b\u4e24\u70b9\u5dee\u5f02\u3002

    • \u672c\u9898\u8981\u6c42\u6700\u5c0f\u503c\uff0c\u56e0\u6b64\u9700\u5c06\u8fd0\u7b97\u7b26 \\(\\max()\\) \u66f4\u6539\u4e3a \\(\\min()\\) \u3002
    • \u4f18\u5316\u4e3b\u4f53\u662f\u786c\u5e01\u6570\u91cf\u800c\u975e\u5546\u54c1\u4ef7\u503c\uff0c\u56e0\u6b64\u5728\u9009\u4e2d\u786c\u5e01\u65f6\u6267\u884c \\(+1\\) \u5373\u53ef\u3002
    \\[ 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\u6570\u91cf\u4e3a \\(0\\) \uff0c\u5373\u9996\u5217\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\u9996\u884c\u6240\u6709 \\(dp[0, a]\\) \u90fd\u7b49\u4e8e \\(+ \\infty\\) \u3002

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_1","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u5e76\u672a\u63d0\u4f9b \\(+ \\infty\\) \u53d8\u91cf\uff0c\u53ea\u80fd\u4f7f\u7528\u6574\u578b int \u7684\u6700\u5927\u503c\u6765\u4ee3\u66ff\u3002\u800c\u8fd9\u53c8\u4f1a\u5bfc\u81f4\u5927\u6570\u8d8a\u754c\uff1a\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e2d\u7684 \\(+ 1\\) \u64cd\u4f5c\u53ef\u80fd\u53d1\u751f\u6ea2\u51fa\u3002

    \u4e3a\u6b64\uff0c\u6211\u4eec\u91c7\u7528\u6570\u5b57 \\(amt + 1\\) \u6765\u8868\u793a\u65e0\u6548\u89e3\uff0c\u56e0\u4e3a\u51d1\u51fa \\(amt\\) \u7684\u786c\u5e01\u6570\u91cf\u6700\u591a\u4e3a \\(amt\\) \u3002\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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig coin_change.py
    def coin_change_dp(coins: list[int], amt: int) -> int:\n    \"\"\"\u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] > a:\n                # \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n
    coin_change.cpp
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(vector<int> &coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n
    coin_change.java
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n + 1][amt + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n
    coin_change.cs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n + 1, amt + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int a = 1; a <= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n
    coin_change.go
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for a := 1; a <= amt; a++ {\n        dp[0][a] = max\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i <= n; i++ {\n        for a := 1; a <= amt; a++ {\n            if coins[i-1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n
    coin_change.swift
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeDP(coins: [Int], amt: Int) -> Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n
    coin_change.js
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: amt + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (let a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n
    coin_change.ts
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeDP(coins: Array<number>, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: amt + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (let a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n
    coin_change.dart
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(List<int> coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n  for (int a = 1; a <= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n  for (int i = 1; i <= n; i++) {\n    for (int a = 1; a <= amt; a++) {\n      if (coins[i - 1] > a) {\n        // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n        dp[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\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n
    coin_change.rs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfn coin_change_dp(coins: &[i32], amt: usize) -> i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] > a as i32 {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n
    coin_change.c
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n
    coin_change.kt
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = min(dp[i - 1][a].toDouble(), (dp[i][a - coins[i - 1]] + 1).toDouble())\n                    .toInt()\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n
    coin_change.rb
    [class]{}-[func]{coin_change_dp}\n
    coin_change.zig
    // \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212\nfn coinChangeDP(comptime coins: []i32, comptime amt: usize) i32 {\n    comptime var n = coins.len;\n    comptime var max = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][amt + 1]i32{[_]i32{0} ** (amt + 1)} ** (n + 1);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (1..amt + 1) |a| {\n        dp[0][a] = max;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (1..n + 1) |i| {\n        for (1..amt + 1) |a| {\n            if (coins[i - 1] > @as(i32, @intCast(a))) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = @min(dp[i - 1][a], dp[i][a - @as(usize, @intCast(coins[i - 1]))] + 1);\n            }\n        }\n    }\n    if (dp[n][amt] != max) {\n        return @intCast(dp[n][amt]);\n    } else {\n        return -1;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-25 \u5c55\u793a\u4e86\u96f6\u94b1\u5151\u6362\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b\uff0c\u548c\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u975e\u5e38\u76f8\u4f3c\u3002

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

    \u56fe 14-25 \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_1","title":"3. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u96f6\u94b1\u5151\u6362\u7684\u7a7a\u95f4\u4f18\u5316\u7684\u5904\u7406\u65b9\u5f0f\u548c\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u4e00\u81f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig coin_change.py
    def coin_change_dp_comp(coins: list[int], amt: int) -> int:\n    \"\"\"\u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        # \u6b63\u5e8f\u904d\u5386\n        for a in range(1, amt + 1):\n            if coins[i - 1] > a:\n                # \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n
    coin_change.cpp
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(vector<int> &coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(amt + 1, MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.java
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.cs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.go
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, amt+1)\n    for i := 1; i <= amt; i++ {\n        dp[i] = max\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        // \u5012\u5e8f\u904d\u5386\n        for a := 1; a <= amt; a++ {\n            if coins[i-1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n
    coin_change.swift
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -> Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n
    coin_change.js
    /* \u96f6\u94b1\u5151\u6362\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: amt + 1 }, () => MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n
    coin_change.ts
    /* \u96f6\u94b1\u5151\u6362\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeDPComp(coins: Array<number>, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: amt + 1 }, () => MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n
    coin_change.dart
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(List<int> coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int a = 1; a <= amt; a++) {\n      if (coins[i - 1] > a) {\n        // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n        dp[a] = dp[a];\n      } else {\n        // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.rs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn coin_change_dp_comp(coins: &[i32], amt: usize) -> i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] > a as i32 {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n
    coin_change.c
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    coin_change.kt
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(amt + 1)\n    Arrays.fill(dp, MAX)\n    dp[0] = 0\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = min(dp[a].toDouble(), (dp[a - coins[i - 1]] + 1).toDouble()).toInt()\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n
    coin_change.rb
    [class]{}-[func]{coin_change_dp_comp}\n
    coin_change.zig
    // \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn coinChangeDPComp(comptime coins: []i32, comptime amt: usize) i32 {\n    comptime var n = coins.len;\n    comptime var max = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** (amt + 1);\n    @memset(&dp, max);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..amt + 1) |a| {\n            if (coins[i - 1] > @as(i32, @intCast(a))) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = @min(dp[a], dp[a - @as(usize, @intCast(coins[i - 1]))] + 1);\n            }\n        }\n    }\n    if (dp[amt] != max) {\n        return @intCast(dp[amt]);\n    } else {\n        return -1;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-ii","title":"14.5.3 \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898 II","text":"

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u786c\u5e01\uff0c\u7b2c \\(i\\) \u79cd\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\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u7684\u786c\u5e01\u7ec4\u5408\u6570\u91cf\u3002\u793a\u4f8b\u5982\u56fe 14-26 \u6240\u793a\u3002

    \u56fe 14-26 \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898 II \u7684\u793a\u4f8b\u6570\u636e

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_2","title":"1. \u00a0 \u52a8\u6001\u89c4\u5212\u601d\u8def","text":"

    \u76f8\u6bd4\u4e8e\u4e0a\u4e00\u9898\uff0c\u672c\u9898\u76ee\u6807\u662f\u6c42\u7ec4\u5408\u6570\u91cf\uff0c\u56e0\u6b64\u5b50\u95ee\u9898\u53d8\u4e3a\uff1a\u524d \\(i\\) \u79cd\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\u987b\u9009\u62e9\u4efb\u4f55\u786c\u5e01\u5373\u53ef\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u56e0\u6b64\u5e94\u5c06\u9996\u5217\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\u9996\u884c\u6240\u6709 \\(dp[0, a]\\) \u90fd\u7b49\u4e8e \\(0\\) \u3002

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    n = len(coins)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # \u521d\u59cb\u5316\u9996\u5217\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] > a:\n                # \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n
    coin_change_ii.cpp
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(vector<int> &coins, int amt) {\n    int n = coins.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (int i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    coin_change_ii.java
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n + 1][amt + 1];\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (int i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    coin_change_ii.cs
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n + 1, amt + 1];\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (int i = 0; i <= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n
    coin_change_ii.go
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // \u521d\u59cb\u5316\u9996\u5217\n    for i := 0; i <= n; i++ {\n        dp[i][0] = 1\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i <= n; i++ {\n        for a := 1; a <= amt; a++ {\n            if coins[i-1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n
    coin_change_ii.swift
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -> Int {\n    let n = coins.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // \u521d\u59cb\u5316\u9996\u5217\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n
    coin_change_ii.js
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: amt + 1 }, () => 0)\n    );\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (let i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    coin_change_ii.ts
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeIIDP(coins: Array<number>, amt: number): number {\n    const n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: amt + 1 }, () => 0)\n    );\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (let i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    coin_change_ii.dart
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(List<int> coins, int amt) {\n  int n = coins.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));\n  // \u521d\u59cb\u5316\u9996\u5217\n  for (int i = 0; i <= n; i++) {\n    dp[i][0] = 1;\n  }\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int a = 1; a <= amt; a++) {\n      if (coins[i - 1] > a) {\n        // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n
    coin_change_ii.rs
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfn coin_change_ii_dp(coins: &[i32], amt: usize) -> i32 {\n    let n = coins.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // \u521d\u59cb\u5316\u9996\u5217\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] > a as i32 {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n
    coin_change_ii.c
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (int i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n
    coin_change_ii.kt
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n
    coin_change_ii.rb
    [class]{}-[func]{coin_change_ii_dp}\n
    coin_change_ii.zig
    // \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212\nfn coinChangeIIDP(comptime coins: []i32, comptime amt: usize) i32 {\n    comptime var n = coins.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][amt + 1]i32{[_]i32{0} ** (amt + 1)} ** (n + 1);\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (0..n + 1) |i| {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..amt + 1) |a| {\n            if (coins[i - 1] > @as(i32, @intCast(a))) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = dp[i - 1][a] + dp[i][a - @as(usize, @intCast(coins[i - 1]))];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_2","title":"3. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7a7a\u95f4\u4f18\u5316\u5904\u7406\u65b9\u5f0f\u76f8\u540c\uff0c\u5220\u9664\u786c\u5e01\u7ef4\u5ea6\u5373\u53ef\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig coin_change_ii.py
    def coin_change_ii_dp_comp(coins: list[int], amt: int) -> int:\n    \"\"\"\u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(coins)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        # \u6b63\u5e8f\u904d\u5386\n        for a in range(1, amt + 1):\n            if coins[i - 1] > a:\n                # \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n
    coin_change_ii.cpp
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(vector<int> &coins, int amt) {\n    int n = coins.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(amt + 1, 0);\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.java
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.cs
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.go
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        // \u5012\u5e8f\u904d\u5386\n        for a := 1; a <= amt; a++ {\n            if coins[i-1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n
    coin_change_ii.swift
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -> Int {\n    let n = coins.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n
    coin_change_ii.js
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: amt + 1 }, () => 0);\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.ts
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeIIDPComp(coins: Array<number>, amt: number): number {\n    const n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: amt + 1 }, () => 0);\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.dart
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(List<int> coins, int amt) {\n  int n = coins.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int a = 1; a <= amt; a++) {\n      if (coins[i - 1] > a) {\n        // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n        dp[a] = dp[a];\n      } else {\n        // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n
    coin_change_ii.rs
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn coin_change_ii_dp_comp(coins: &[i32], amt: usize) -> i32 {\n    let n = coins.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] > a as i32 {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n
    coin_change_ii.c
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    coin_change_ii.kt
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n
    coin_change_ii.rb
    [class]{}-[func]{coin_change_ii_dp_comp}\n
    coin_change_ii.zig
    // \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn coinChangeIIDPComp(comptime coins: []i32, comptime amt: usize) i32 {\n    comptime var n = coins.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** (amt + 1);\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..amt + 1) |a| {\n            if (coins[i - 1] > @as(i32, @intCast(a))) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = dp[a] + dp[a - @as(usize, @intCast(coins[i - 1]))];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_graph/","title":"\u7b2c 9 \u7ae0 \u00a0 \u56fe","text":"

    Abstract

    \u5728\u751f\u547d\u65c5\u9014\u4e2d\uff0c\u6211\u4eec\u5c31\u50cf\u662f\u4e00\u4e2a\u4e2a\u8282\u70b9\uff0c\u88ab\u65e0\u6570\u770b\u4e0d\u89c1\u7684\u8fb9\u76f8\u8fde\u3002

    \u6bcf\u4e00\u6b21\u7684\u76f8\u8bc6\u4e0e\u76f8\u79bb\uff0c\u90fd\u5728\u8fd9\u5f20\u5de8\u5927\u7684\u7f51\u7edc\u56fe\u4e2d\u7559\u4e0b\u72ec\u7279\u7684\u5370\u8bb0\u3002

    "},{"location":"chapter_graph/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 9.1 \u00a0 \u56fe
    • 9.2 \u00a0 \u56fe\u57fa\u7840\u64cd\u4f5c
    • 9.3 \u00a0 \u56fe\u7684\u904d\u5386
    • 9.4 \u00a0 \u5c0f\u7ed3
    "},{"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} \\]

    \u5982\u679c\u5c06\u9876\u70b9\u770b\u4f5c\u8282\u70b9\uff0c\u5c06\u8fb9\u770b\u4f5c\u8fde\u63a5\u5404\u4e2a\u8282\u70b9\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5c06\u56fe\u770b\u4f5c\u4e00\u79cd\u4ece\u94fe\u8868\u62d3\u5c55\u800c\u6765\u7684\u6570\u636e\u7ed3\u6784\u3002\u5982\u56fe 9-1 \u6240\u793a\uff0c\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\u56e0\u800c\u66f4\u4e3a\u590d\u6742\u3002

    \u56fe 9-1 \u00a0 \u94fe\u8868\u3001\u6811\u3001\u56fe\u4e4b\u95f4\u7684\u5173\u7cfb

    "},{"location":"chapter_graph/graph/#911","title":"9.1.1 \u00a0 \u56fe\u7684\u5e38\u89c1\u7c7b\u578b\u4e0e\u672f\u8bed","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\uff0c\u5982\u56fe 9-2 \u6240\u793a\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\u3002
    • \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\u3002

    \u56fe 9-2 \u00a0 \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\uff0c\u5982\u56fe 9-3 \u6240\u793a\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\u3002
    • \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\u3002

    \u56fe 9-3 \u00a0 \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\u5982\u56fe 9-4 \u6240\u793a\u7684\u300c\u6709\u6743\u56fe weighted graph\u300d\u3002\u4f8b\u5982\u5728\u300a\u738b\u8005\u8363\u8000\u300b\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

    \u56fe 9-4 \u00a0 \u6709\u6743\u56fe\u4e0e\u65e0\u6743\u56fe

    \u56fe\u6570\u636e\u7ed3\u6784\u5305\u542b\u4ee5\u4e0b\u5e38\u7528\u672f\u8bed\u3002

    • \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\u56fe 9-4 \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\u56fe 9-4 \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\uff1a\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/#912","title":"9.1.2 \u00a0 \u56fe\u7684\u8868\u793a","text":"

    \u56fe\u7684\u5e38\u7528\u8868\u793a\u65b9\u5f0f\u5305\u62ec\u201c\u90bb\u63a5\u77e9\u9635\u201d\u548c\u201c\u90bb\u63a5\u8868\u201d\u3002\u4ee5\u4e0b\u4f7f\u7528\u65e0\u5411\u56fe\u8fdb\u884c\u4e3e\u4f8b\u3002

    "},{"location":"chapter_graph/graph/#1","title":"1. \u00a0 \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\u56fe 9-5 \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

    \u56fe 9-5 \u00a0 \u56fe\u7684\u90bb\u63a5\u77e9\u9635\u8868\u793a

    \u90bb\u63a5\u77e9\u9635\u5177\u6709\u4ee5\u4e0b\u7279\u6027\u3002

    • \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\\) \u548c \\(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\u6539\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":"2. \u00a0 \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\\) \u4e2a\u94fe\u8868\u5bf9\u5e94\u9876\u70b9 \\(i\\) \uff0c\u5176\u4e2d\u5b58\u50a8\u4e86\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\uff08\u4e0e\u8be5\u9876\u70b9\u76f8\u8fde\u7684\u9876\u70b9\uff09\u3002\u56fe 9-6 \u5c55\u793a\u4e86\u4e00\u4e2a\u4f7f\u7528\u90bb\u63a5\u8868\u5b58\u50a8\u7684\u56fe\u7684\u793a\u4f8b\u3002

    \u56fe 9-6 \u00a0 \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\u56fe 9-6 \uff0c\u90bb\u63a5\u8868\u7ed3\u6784\u4e0e\u54c8\u5e0c\u8868\u4e2d\u7684\u201c\u94fe\u5f0f\u5730\u5740\u201d\u975e\u5e38\u76f8\u4f3c\uff0c\u56e0\u6b64\u6211\u4eec\u4e5f\u53ef\u4ee5\u91c7\u7528\u7c7b\u4f3c\u7684\u65b9\u6cd5\u6765\u4f18\u5316\u6548\u7387\u3002\u6bd4\u5982\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)\\) \uff1b\u8fd8\u53ef\u4ee5\u628a\u94fe\u8868\u8f6c\u6362\u4e3a\u54c8\u5e0c\u8868\uff0c\u4ece\u800c\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u964d\u81f3 \\(O(1)\\) \u3002

    "},{"location":"chapter_graph/graph/#913","title":"9.1.3 \u00a0 \u56fe\u7684\u5e38\u89c1\u5e94\u7528","text":"

    \u5982\u8868 9-1 \u6240\u793a\uff0c\u8bb8\u591a\u73b0\u5b9e\u7cfb\u7edf\u53ef\u4ee5\u7528\u56fe\u6765\u5efa\u6a21\uff0c\u76f8\u5e94\u7684\u95ee\u9898\u4e5f\u53ef\u4ee5\u7ea6\u5316\u4e3a\u56fe\u8ba1\u7b97\u95ee\u9898\u3002

    \u8868 9-1 \u00a0 \u73b0\u5b9e\u751f\u6d3b\u4e2d\u5e38\u89c1\u7684\u56fe

    \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\u7684\u57fa\u7840\u64cd\u4f5c","text":"

    \u56fe\u7684\u57fa\u7840\u64cd\u4f5c\u53ef\u5206\u4e3a\u5bf9\u201c\u8fb9\u201d\u7684\u64cd\u4f5c\u548c\u5bf9\u201c\u9876\u70b9\u201d\u7684\u64cd\u4f5c\u3002\u5728\u201c\u90bb\u63a5\u77e9\u9635\u201d\u548c\u201c\u90bb\u63a5\u8868\u201d\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\u5404\u79cd\u64cd\u4f5c\u7684\u5b9e\u73b0\u65b9\u5f0f\u5982\u56fe 9-7 \u6240\u793a\u3002

    • \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

    \u56fe 9-7 \u00a0 \u90bb\u63a5\u77e9\u9635\u7684\u521d\u59cb\u5316\u3001\u589e\u5220\u8fb9\u3001\u589e\u5220\u9876\u70b9

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u8868\u793a\u56fe\u7684\u5b9e\u73b0\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_adjacency_matrix.py
    class GraphAdjMat:\n    \"\"\"\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\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\n        self.vertices: list[int] = []\n        # \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n        self.adj_mat: list[list[int]] = []\n        # \u6dfb\u52a0\u9876\u70b9\n        for val in vertices:\n            self.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\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\n        n = self.size()\n        # \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        self.vertices.append(val)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"\u5220\u9664\u9876\u70b9\"\"\"\n        if index >= self.size():\n            raise IndexError()\n        # \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        self.vertices.pop(index)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        self.adj_mat.pop(index)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\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\n        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\n            raise IndexError()\n        # \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\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\n        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"\u6253\u5370\u90bb\u63a5\u77e9\u9635\"\"\"\n        print(\"\u9876\u70b9\u5217\u8868 =\", self.vertices)\n        print(\"\u90bb\u63a5\u77e9\u9635 =\")\n        print_matrix(self.adj_mat)\n
    graph_adjacency_matrix.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    vector<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\n    vector<vector<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    GraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {\n        // \u6dfb\u52a0\u9876\u70b9\n        for (int val : vertices) {\n            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\n        for (const vector<int> &edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    void addVertex(int val) {\n        int n = size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.push_back(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        adjMat.emplace_back(vector<int>(n, 0));\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (vector<int> &row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    void removeVertex(int index) {\n        if (index >= size()) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.erase(vertices.begin() + index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.erase(adjMat.begin() + index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (vector<int> &row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    void addEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    void removeEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    void print() {\n        cout << \"\u9876\u70b9\u5217\u8868 = \";\n        printVector(vertices);\n        cout << \"\u90bb\u63a5\u77e9\u9635 =\" << endl;\n        printVectorMatrix(adjMat);\n    }\n};\n
    graph_adjacency_matrix.java
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    List<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\n    List<List<Integer>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList<>();\n        this.adjMat = new ArrayList<>();\n        // \u6dfb\u52a0\u9876\u70b9\n        for (int val : vertices) {\n            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\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void addVertex(int val) {\n        int n = size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.add(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        List<Integer> newRow = new ArrayList<>(n);\n        for (int j = 0; j < n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (List<Integer> row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void removeVertex(int index) {\n        if (index >= size())\n            throw new IndexOutOfBoundsException();\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (List<Integer> row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void addEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void removeEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    public void print() {\n        System.out.print(\"\u9876\u70b9\u5217\u8868 = \");\n        System.out.println(vertices);\n        System.out.println(\"\u90bb\u63a5\u77e9\u9635 =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n
    graph_adjacency_matrix.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    List<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\n    List<List<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        foreach (int val in vertices) {\n            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\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void AddVertex(int val) {\n        int n = Size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.Add(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        List<int> newRow = new(n);\n        for (int j = 0; j < n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        foreach (List<int> row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void RemoveVertex(int index) {\n        if (index >= Size())\n            throw new IndexOutOfRangeException();\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.RemoveAt(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.RemoveAt(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        foreach (List<int> row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void AddEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void RemoveEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    public void Print() {\n        Console.Write(\"\u9876\u70b9\u5217\u8868 = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"\u90bb\u63a5\u77e9\u9635 =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\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\n    vertices []int\n    // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n    adjMat [][]int\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // \u6dfb\u52a0\u9876\u70b9\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // \u521d\u59cb\u5316\u56fe\n    g := &graphAdjMat{\n        vertices: vertices,\n        adjMat:   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\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n    g.vertices = append(g.vertices, val)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index >= g.size() {\n        return\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\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\n    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\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\n    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\t\u9876\u70b9\u5217\u8868 = %v\\n\", g.vertices)\n    fmt.Printf(\"\\t\u90bb\u63a5\u77e9\u9635 = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n
    graph_adjacency_matrix.swift
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    private 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\n    private var adjMat: [[Int]] // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // \u6dfb\u52a0\u9876\u70b9\n        for val in vertices {\n            addVertex(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\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    func size() -> Int {\n        vertices.count\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    func addVertex(val: Int) {\n        let n = size()\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.append(val)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    func removeVertex(index: Int) {\n        if index >= size() {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.remove(at: index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.remove(at: index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    func addEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    func removeEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    func print() {\n        Swift.print(\"\u9876\u70b9\u5217\u8868 = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"\u90bb\u63a5\u77e9\u9635 =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n
    graph_adjacency_matrix.js
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    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\n    adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        for (const val of vertices) {\n            this.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\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(val) {\n        const n = this.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        this.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        const newRow = [];\n        for (let j = 0; j < n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(index) {\n        if (index >= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        this.vertices.splice(index, 1);\n\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        this.adjMat.splice(index, 1);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    addEdge(i, j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    removeEdge(i, j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    print() {\n        console.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\n        console.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 {\n    vertices: 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\n    adjMat: number[][]; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        for (const val of vertices) {\n            this.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\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        this.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        const newRow: number[] = [];\n        for (let j: number = 0; j < n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(index: number): void {\n        if (index >= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        this.vertices.splice(index, 1);\n\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        this.adjMat.splice(index, 1);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    addEdge(i: number, j: number): void {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    removeEdge(i: number, j: number): void {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    print(): void {\n        console.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\n        console.log('\u90bb\u63a5\u77e9\u9635 =', this.adjMat);\n    }\n}\n
    graph_adjacency_matrix.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n  List<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\n  List<List<int>> adjMat = []; //\u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  GraphAdjMat(List<int> vertices, List<List<int>> edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // \u6dfb\u52a0\u9876\u70b9\n    for (int val in vertices) {\n      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\n    for (List<int> e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n  int size() {\n    return vertices.length;\n  }\n\n  /* \u6dfb\u52a0\u9876\u70b9 */\n  void addVertex(int val) {\n    int n = size();\n    // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n    vertices.add(val);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n    List<int> newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n    for (List<int> row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* \u5220\u9664\u9876\u70b9 */\n  void removeVertex(int index) {\n    if (index >= size()) {\n      throw IndexError;\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    vertices.removeAt(index);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    adjMat.removeAt(index);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for (List<int> row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* \u6dfb\u52a0\u8fb9 */\n  // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n  void addEdge(int i, int j) {\n    // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n      throw IndexError;\n    }\n    // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* \u5220\u9664\u8fb9 */\n  // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n  void removeEdge(int i, int j) {\n    // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n  void printAdjMat() {\n    print(\"\u9876\u70b9\u5217\u8868 = $vertices\");\n    print(\"\u90bb\u63a5\u77e9\u9635 = \");\n    printMatrix(adjMat);\n  }\n}\n
    graph_adjacency_matrix.rs
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\u578b */\npub struct GraphAdjMat {\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\n    pub vertices: Vec<i32>,\n    // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n    pub adj_mat: Vec<Vec<i32>>,\n}\n\nimpl GraphAdjMat {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(vertices: Vec<i32>, edges: Vec<[usize; 2]>) -> Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // \u6dfb\u52a0\u9876\u70b9\n        for val in vertices {\n            graph.add_vertex(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\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    pub fn size(&self) -> usize {\n        self.vertices.len()\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    pub fn add_vertex(&mut self, val: i32) {\n        let n = self.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        self.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        self.adj_mat.push(vec![0; n]);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for row in &mut self.adj_mat {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    pub fn remove_vertex(&mut self, index: usize) {\n        if index >= self.size() {\n            panic!(\"index error\")\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        self.vertices.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        self.adj_mat.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for row in &mut self.adj_mat {\n            row.remove(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    pub fn add_edge(&mut self, i: usize, j: usize) {\n        // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i >= self.size() || j >= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    pub fn remove_edge(&mut self, i: usize, j: usize) {\n        // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i >= self.size() || j >= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    pub fn print(&self) {\n        println!(\"\u9876\u70b9\u5217\u8868 = {:?}\", self.vertices);\n        println!(\"\u90bb\u63a5\u77e9\u9635 =\");\n        println!(\"[\");\n        for row in &self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n
    graph_adjacency_matrix.c
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7ed3\u6784\u4f53 */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* \u6784\u9020\u51fd\u6570 */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph->size = 0;\n    for (int i = 0; i < MAX_SIZE; i++) {\n        for (int j = 0; j < MAX_SIZE; j++) {\n            graph->adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph->size == MAX_SIZE) {\n        fprintf(stderr, \"\u56fe\u7684\u9876\u70b9\u6570\u91cf\u5df2\u8fbe\u6700\u5927\u503c\\n\");\n        return;\n    }\n    // \u6dfb\u52a0\u7b2c n \u4e2a\u9876\u70b9\uff0c\u5e76\u5c06\u7b2c n \u884c\u548c\u5217\u7f6e\u96f6\n    int n = graph->size;\n    graph->vertices[n] = val;\n    for (int i = 0; i <= n; i++) {\n        graph->adjMat[n][i] = graph->adjMat[i][n] = 0;\n    }\n    graph->size++;\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index < 0 || index >= graph->size) {\n        fprintf(stderr, \"\u9876\u70b9\u7d22\u5f15\u8d8a\u754c\\n\");\n        return;\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    for (int i = index; i < graph->size - 1; i++) {\n        graph->vertices[i] = graph->vertices[i + 1];\n    }\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    for (int i = index; i < graph->size - 1; i++) {\n        for (int j = 0; j < graph->size; j++) {\n            graph->adjMat[i][j] = graph->adjMat[i + 1][j];\n        }\n    }\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for (int i = 0; i < graph->size; i++) {\n        for (int j = index; j < graph->size - 1; j++) {\n            graph->adjMat[i][j] = graph->adjMat[i][j + 1];\n        }\n    }\n    graph->size--;\n}\n\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {\n        fprintf(stderr, \"\u8fb9\u7d22\u5f15\u8d8a\u754c\u6216\u76f8\u7b49\\n\");\n        return;\n    }\n    graph->adjMat[i][j] = 1;\n    graph->adjMat[j][i] = 1;\n}\n\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {\n        fprintf(stderr, \"\u8fb9\u7d22\u5f15\u8d8a\u754c\u6216\u76f8\u7b49\\n\");\n        return;\n    }\n    graph->adjMat[i][j] = 0;\n    graph->adjMat[j][i] = 0;\n}\n\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"\u9876\u70b9\u5217\u8868 = \");\n    printArray(graph->vertices, graph->size);\n    printf(\"\u90bb\u63a5\u77e9\u9635 =\\n\");\n    for (int i = 0; i < graph->size; i++) {\n        printArray(graph->adjMat[i], graph->size);\n    }\n}\n
    graph_adjacency_matrix.kt
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat(vertices: IntArray, edges: Array<IntArray>) {\n    val vertices: MutableList<Int> = ArrayList() // \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\n    val adjMat: MutableList<MutableList<Int>> = ArrayList() // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        // \u6dfb\u52a0\u9876\u70b9\n        for (vertex in vertices) {\n            addVertex(vertex)\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\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    fun addVertex(value: Int) {\n        val n = size()\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.add(value)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        val newRow: MutableList<Int> = mutableListOf()\n        for (j in 0..<n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    fun removeVertex(index: Int) {\n        if (index >= size()) throw IndexOutOfBoundsException()\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.removeAt(index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.removeAt(index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    fun addEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) throw java.lang.IndexOutOfBoundsException()\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    fun removeEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) throw java.lang.IndexOutOfBoundsException()\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    fun print() {\n        print(\"\u9876\u70b9\u5217\u8868 = \")\n        println(vertices);\n        println(\"\u90bb\u63a5\u77e9\u9635 =\");\n        printMatrix(adjMat)\n    }\n}\n
    graph_adjacency_matrix.rb
    [class]{GraphAdjMat}-[func]{}\n
    graph_adjacency_matrix.zig
    [class]{GraphAdjMat}-[func]{}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u53ef\u6839\u636e\u56fe 9-8 \u6240\u793a\u7684\u65b9\u6cd5\u5b9e\u73b0\u5404\u79cd\u64cd\u4f5c\u3002

    • \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

    \u56fe 9-8 \u00a0 \u90bb\u63a5\u8868\u7684\u521d\u59cb\u5316\u3001\u589e\u5220\u8fb9\u3001\u589e\u5220\u9876\u70b9

    \u4ee5\u4e0b\u662f\u90bb\u63a5\u8868\u7684\u4ee3\u7801\u5b9e\u73b0\u3002\u5bf9\u6bd4\u56fe 9-8 \uff0c\u5b9e\u9645\u4ee3\u7801\u6709\u4ee5\u4e0b\u4e0d\u540c\u3002

    • \u4e3a\u4e86\u65b9\u4fbf\u6dfb\u52a0\u4e0e\u5220\u9664\u9876\u70b9\uff0c\u4ee5\u53ca\u7b80\u5316\u4ee3\u7801\uff0c\u6211\u4eec\u4f7f\u7528\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\u6765\u4ee3\u66ff\u94fe\u8868\u3002
    • \u4f7f\u7528\u54c8\u5e0c\u8868\u6765\u5b58\u50a8\u90bb\u63a5\u8868\uff0ckey \u4e3a\u9876\u70b9\u5b9e\u4f8b\uff0cvalue \u4e3a\u8be5\u9876\u70b9\u7684\u90bb\u63a5\u9876\u70b9\u5217\u8868\uff08\u94fe\u8868\uff09\u3002

    \u53e6\u5916\uff0c\u6211\u4eec\u5728\u90bb\u63a5\u8868\u4e2d\u4f7f\u7528 Vertex \u7c7b\u6765\u8868\u793a\u9876\u70b9\uff0c\u8fd9\u6837\u505a\u7684\u539f\u56e0\u662f\uff1a\u5982\u679c\u4e0e\u90bb\u63a5\u77e9\u9635\u4e00\u6837\uff0c\u7528\u5217\u8868\u7d22\u5f15\u6765\u533a\u5206\u4e0d\u540c\u9876\u70b9\uff0c\u90a3\u4e48\u5047\u8bbe\u8981\u5220\u9664\u7d22\u5f15\u4e3a \\(i\\) \u7684\u9876\u70b9\uff0c\u5219\u9700\u904d\u5386\u6574\u4e2a\u90bb\u63a5\u8868\uff0c\u5c06\u6240\u6709\u5927\u4e8e \\(i\\) \u7684\u7d22\u5f15\u5168\u90e8\u51cf \\(1\\) \uff0c\u6548\u7387\u5f88\u4f4e\u3002\u800c\u5982\u679c\u6bcf\u4e2a\u9876\u70b9\u90fd\u662f\u552f\u4e00\u7684 Vertex \u5b9e\u4f8b\uff0c\u5220\u9664\u67d0\u4e00\u9876\u70b9\u4e4b\u540e\u5c31\u65e0\u987b\u6539\u52a8\u5176\u4ed6\u9876\u70b9\u4e86\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_adjacency_list.py
    class GraphAdjList:\n    \"\"\"\u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        # \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"\u6dfb\u52a0\u8fb9\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # \u6dfb\u52a0\u8fb9 vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"\u5220\u9664\u8fb9\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # \u5220\u9664\u8fb9 vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\n        if vet in self.adj_list:\n            return\n        # \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"\u5220\u9664\u9876\u70b9\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        self.adj_list.pop(vet)\n        # \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u90bb\u63a5\u8868\"\"\"\n        print(\"\u90bb\u63a5\u8868 =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n
    graph_adjacency_list.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n  public:\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    unordered_map<Vertex *, vector<Vertex *>> adjList;\n\n    /* \u5728 vector \u4e2d\u5220\u9664\u6307\u5b9a\u8282\u70b9 */\n    void remove(vector<Vertex *> &vec, Vertex *vet) {\n        for (int i = 0; i < vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    GraphAdjList(const vector<vector<Vertex *>> &edges) {\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const vector<Vertex *> &edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int size() {\n        return adjList.size();\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = vector<Vertex *>();\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.erase(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (auto &adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    void print() {\n        cout << \"\u90bb\u63a5\u8868 =\" << endl;\n        for (auto &adj : adjList) {\n            const auto &key = adj.first;\n            const auto &vec = adj.second;\n            cout << key->val << \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n
    graph_adjacency_list.java
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    Map<Vertex, List<Vertex>> adjList;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap<>();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList.put(vet, new ArrayList<>());\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (List<Vertex> list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public void print() {\n        System.out.println(\"\u90bb\u63a5\u8868 =\");\n        for (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {\n            List<Integer> tmp = new ArrayList<>();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n
    graph_adjacency_list.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    public Dictionary<Vertex, List<Vertex>> adjList;\n\n    /* \u6784\u9020\u51fd\u6570 */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList.Add(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.Remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        foreach (List<Vertex> list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public void Print() {\n        Console.WriteLine(\"\u90bb\u63a5\u8868 =\");\n        foreach (KeyValuePair<Vertex, List<Vertex>> pair in adjList) {\n            List<int> tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList map[Vertex][]Vertex\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* \u6dfb\u52a0\u8fb9 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2, \u6dfb\u52a0\u533f\u540d struct{},\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* \u5220\u9664\u8fb9 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    delete(g.adjList, vet)\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"\u90bb\u63a5\u8868 = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public func size() -> Int {\n        adjList.count\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = []\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.removeValue(forKey: vet)\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public func print() {\n        Swift.print(\"\u90bb\u63a5\u8868 =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(edges) {\n        this.adjList = new Map();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        this.adjList.set(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        this.adjList.delete(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index > -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    print() {\n        console.log('\u90bb\u63a5\u8868 =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList: Map<Vertex, Vertex[]>;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        this.adjList.set(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        this.adjList.delete(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index > -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    print(): void {\n        console.log('\u90bb\u63a5\u8868 =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n
    graph_adjacency_list.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n  // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n  Map<Vertex, List<Vertex>> adjList = {};\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  GraphAdjList(List<List<Vertex>> edges) {\n    for (List<Vertex> edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n  int size() {\n    return adjList.length;\n  }\n\n  /* \u6dfb\u52a0\u8fb9 */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* \u5220\u9664\u8fb9 */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* \u6dfb\u52a0\u9876\u70b9 */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    adjList[vet] = [];\n  }\n\n  /* \u5220\u9664\u9876\u70b9 */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    adjList.remove(vet);\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* \u6253\u5370\u90bb\u63a5\u8868 */\n  void printAdjList() {\n    print(\"\u90bb\u63a5\u8868 =\");\n    adjList.forEach((key, value) {\n      List<int> tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n
    graph_adjacency_list.rs
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\u578b */\npub struct GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    pub adj_list: HashMap<Vertex, Vec<Vertex>>,\n}\n\nimpl GraphAdjList {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(edges: Vec<[Vertex; 2]>) -> Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    #[allow(unused)]\n    pub fn size(&self) -> usize {\n        self.adj_list.len()\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    pub fn add_edge(&mut self, vet1: Vertex, vet2: Vertex) {\n        if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2\n        {\n            panic!(\"value error\");\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        self.adj_list.get_mut(&vet1).unwrap().push(vet2);\n        self.adj_list.get_mut(&vet2).unwrap().push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    #[allow(unused)]\n    pub fn remove_edge(&mut self, vet1: Vertex, vet2: Vertex) {\n        if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2\n        {\n            panic!(\"value error\");\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        self.adj_list\n            .get_mut(&vet1)\n            .unwrap()\n            .retain(|&vet| vet != vet2);\n        self.adj_list\n            .get_mut(&vet2)\n            .unwrap()\n            .retain(|&vet| vet != vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    pub fn add_vertex(&mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&vet) {\n            return;\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    #[allow(unused)]\n    pub fn remove_vertex(&mut self, vet: Vertex) {\n        if !self.adj_list.contains_key(&vet) {\n            panic!(\"value error\");\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        self.adj_list.remove(&vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for list in self.adj_list.values_mut() {\n            list.retain(|&v| v != vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    pub fn print(&self) {\n        println!(\"\u90bb\u63a5\u8868 =\");\n        for (vertex, list) in &self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::<Vec<i32>>();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n
    graph_adjacency_list.c
    /* \u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // \u9876\u70b9\n    struct AdjListNode *next; // \u540e\u7ee7\u8282\u70b9\n} AdjListNode;\n\n/* \u67e5\u627e\u9876\u70b9\u5bf9\u5e94\u7684\u8282\u70b9 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i < graph->size; i++) {\n        if (graph->heads[i]->vertex == vet) {\n            return graph->heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* \u6dfb\u52a0\u8fb9\u8f85\u52a9\u51fd\u6570 */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node->vertex = vet;\n    // \u5934\u63d2\u6cd5\n    node->next = head->next;\n    head->next = node;\n}\n\n/* \u5220\u9664\u8fb9\u8f85\u52a9\u51fd\u6570 */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head->next;\n    // \u5728\u94fe\u8868\u4e2d\u641c\u7d22 vet \u5bf9\u5e94\u8282\u70b9\n    while (cur != NULL && cur->vertex != vet) {\n        pre = cur;\n        cur = cur->next;\n    }\n    if (cur == NULL)\n        return;\n    // \u5c06 vet \u5bf9\u5e94\u8282\u70b9\u4ece\u94fe\u8868\u4e2d\u5220\u9664\n    pre->next = cur->next;\n    // \u91ca\u653e\u5185\u5b58\n    free(cur);\n}\n\n/* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // \u8282\u70b9\u6570\u7ec4\n    int size;                     // \u8282\u70b9\u6570\u91cf\n} GraphAdjList;\n\n/* \u6784\u9020\u51fd\u6570 */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph->size = 0;\n    for (int i = 0; i < MAX_SIZE; i++) {\n        graph->heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i < graph->size; i++) {\n        AdjListNode *cur = graph->heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur->next;\n            if (cur != graph->heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph->heads[i]->vertex);\n        free(graph->heads[i]);\n    }\n    free(graph);\n}\n\n/* \u67e5\u627e\u9876\u70b9\u5bf9\u5e94\u7684\u8282\u70b9 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i < graph->size; i++) {\n        if (graph->heads[i]->vertex == vet) {\n            return graph->heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* \u6dfb\u52a0\u8fb9 */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL && head2 != NULL && head1 != head2);\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* \u5220\u9664\u8fb9 */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL && head2 != NULL);\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    removeEdgeHelper(head1, head2->vertex);\n    removeEdgeHelper(head2, head1->vertex);\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL && graph->size < MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head->vertex = vet;\n    head->next = NULL;\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    graph->heads[graph->size++] = head;\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur->next;\n        free(pre);\n    }\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    for (int i = 0; i < graph->size; i++) {\n        cur = graph->heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur->next;\n            if (cur && cur->vertex == vet) {\n                pre->next = cur->next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // \u5c06\u8be5\u9876\u70b9\u4e4b\u540e\u7684\u9876\u70b9\u5411\u524d\u79fb\u52a8\uff0c\u4ee5\u586b\u8865\u7a7a\u7f3a\n    int i;\n    for (i = 0; i < graph->size; i++) {\n        if (graph->heads[i] == node)\n            break;\n    }\n    for (int j = i; j < graph->size - 1; j++) {\n        graph->heads[j] = graph->heads[j + 1];\n    }\n    graph->size--;\n    free(vet);\n}\n
    graph_adjacency_list.kt
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList(edges: Array<Array<Vertex?>>) {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    val adjList: MutableMap<Vertex, MutableList<Vertex>> = HashMap()\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (edge in edges) {\n            addVertex(edge[0]!!);\n            addVertex(edge[1]!!);\n            addEdge(edge[0]!!, edge[1]!!);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1]?.remove(vet2);\n        adjList[vet2]?.remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = mutableListOf()\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    fun print() {\n        println(\"\u90bb\u63a5\u8868 =\")\n        for (pair in adjList.entries) {\n            val tmp = ArrayList<Int>()\n            for (vertex in pair.value) {\n                tmp.add(vertex.value)\n            }\n            println(\"${pair.key.value}: $tmp,\")\n        }\n    }\n}\n
    graph_adjacency_list.rb
    [class]{GraphAdjList}-[func]{}\n
    graph_adjacency_list.zig
    [class]{GraphAdjList}-[func]{}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u8868 9-2 \u5bf9\u6bd4\u4e86\u90bb\u63a5\u77e9\u9635\u548c\u90bb\u63a5\u8868\u7684\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u3002

    \u8868 9-2 \u00a0 \u90bb\u63a5\u77e9\u9635\u4e0e\u90bb\u63a5\u8868\u5bf9\u6bd4

    \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\u8868 9-2 \uff0c\u4f3c\u4e4e\u90bb\u63a5\u8868\uff08\u54c8\u5e0c\u8868\uff09\u7684\u65f6\u95f4\u6548\u7387\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\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":"

    \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\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\u3002

    \u56fe\u548c\u6811\u90fd\u9700\u8981\u5e94\u7528\u641c\u7d22\u7b97\u6cd5\u6765\u5b9e\u73b0\u904d\u5386\u64cd\u4f5c\u3002\u56fe\u7684\u904d\u5386\u65b9\u5f0f\u4e5f\u53ef\u5206\u4e3a\u4e24\u79cd\uff1a\u300c\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u300d\u548c\u300c\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u300d\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\u67d0\u4e2a\u8282\u70b9\u51fa\u53d1\uff0c\u59cb\u7ec8\u4f18\u5148\u8bbf\u95ee\u8ddd\u79bb\u6700\u8fd1\u7684\u9876\u70b9\uff0c\u5e76\u4e00\u5c42\u5c42\u5411\u5916\u6269\u5f20\u3002\u5982\u56fe 9-9 \u6240\u793a\uff0c\u4ece\u5de6\u4e0a\u89d2\u9876\u70b9\u51fa\u53d1\uff0c\u9996\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

    \u56fe 9-9 \u00a0 \u56fe\u7684\u5e7f\u5ea6\u4f18\u5148\u904d\u5386

    "},{"location":"chapter_graph/graph_traversal/#1","title":"1. \u00a0 \u7b97\u6cd5\u5b9e\u73b0","text":"

    BFS \u901a\u5e38\u501f\u52a9\u961f\u5217\u6765\u5b9e\u73b0\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\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\u3002
    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\u3002
    3. \u5faa\u73af\u6b65\u9aa4 2. \uff0c\u76f4\u5230\u6240\u6709\u9876\u70b9\u88ab\u8bbf\u95ee\u5b8c\u6bd5\u540e\u7ed3\u675f\u3002

    \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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_bfs.py
    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n    \"\"\"\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\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\n    res = []\n    # \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited = set[Vertex]([start_vet])\n    # \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    que = deque[Vertex]([start_vet])\n    # \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while len(que) > 0:\n        vet = que.popleft()  # \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        # \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.append(adj_vet)  # \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adj_vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    # \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n
    graph_bfs.cpp
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    vector<Vertex *> res;\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    unordered_set<Vertex *> visited = {startVet};\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    queue<Vertex *> que;\n    que.push(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push_back(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.push(adjVet);        // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.emplace(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.java
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = new ArrayList<>();\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    Set<Vertex> visited = new HashSet<>();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue<Vertex> que = new LinkedList<>();\n    que.offer(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.add(vet);            // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.offer(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.cs
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    HashSet<Vertex> visited = [startVet];\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue<Vertex> que = new();\n    que.Enqueue(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.Count > 0) {\n        Vertex vet = que.Dequeue(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.Add(vet);               // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.Enqueue(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.Add(adjVet);   // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.go
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    res := make([]Vertex, 0)\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS, \u4f7f\u7528\u5207\u7247\u6a21\u62df\u961f\u5217\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    for len(queue) > 0 {\n        // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        vet := queue[0]\n        queue = queue[1:]\n        // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        res = append(res, vet)\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.swift
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    var res: [Vertex] = []\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    var visited: Set<Vertex> = [startVet]\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    var que: [Vertex] = [startVet]\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while !que.isEmpty {\n        let vet = que.removeFirst() // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.append(adjVet) // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.insert(adjVet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.js
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited = new Set();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    const que = [startVet];\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.length) {\n        const vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.ts
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res: Vertex[] = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited: Set<Vertex> = new Set();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    const que = [startVet];\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.length) {\n        const vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.dart
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n  List<Vertex> res = [];\n  // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n  Set<Vertex> visited = {};\n  visited.add(startVet);\n  // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n  Queue<Vertex> que = Queue();\n  que.add(startVet);\n  // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n    res.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n      }\n      que.add(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n      visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    }\n  }\n  // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n  return res;\n}\n
    graph_bfs.rs
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    let mut res = vec![];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while !que.is_empty() {\n        let vet = que.pop_front().unwrap(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        if let Some(adj_vets) = graph.adj_list.get(&vet) {\n            for &adj_vet in adj_vets {\n                if visited.contains(&adj_vet) {\n                    continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n                }\n                que.push_back(adj_vet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n                visited.insert(adj_vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n            }\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    res\n}\n
    graph_bfs.c
    /* \u8282\u70b9\u961f\u5217\u7ed3\u6784\u4f53 */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* \u6784\u9020\u51fd\u6570 */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q->front = q->rear = q->size = 0;\n    return q;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nint isEmpty(Queue *q) {\n    return q->size == 0;\n}\n\n/* \u5165\u961f\u64cd\u4f5c */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q->vertices[q->rear] = vet;\n    q->rear = (q->rear + 1) % MAX_SIZE;\n    q->size++;\n}\n\n/* \u51fa\u961f\u64cd\u4f5c */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q->vertices[q->front];\n    q->front = (q->front + 1) % MAX_SIZE;\n    q->size--;\n    return vet;\n}\n\n/* \u68c0\u67e5\u9876\u70b9\u662f\u5426\u5df2\u88ab\u8bbf\u95ee */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // \u904d\u5386\u67e5\u627e\u8282\u70b9\uff0c\u4f7f\u7528 O(n) \u65f6\u95f4\n    for (int i = 0; i < size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res[(*resSize)++] = vet;      // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            if (!isVisited(visited, *visitedSize, node->vertex)) {\n                enqueue(queue, node->vertex);             // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n                visited[(*visitedSize)++] = node->vertex; // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n            }\n            node = node->next;\n        }\n    }\n    // \u91ca\u653e\u5185\u5b58\n    free(queue);\n}\n
    graph_bfs.kt
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): List<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    val res: MutableList<Vertex> = ArrayList()\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    val visited: MutableSet<Vertex> = HashSet()\n    visited.add(startVet)\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    val que: Queue<Vertex> = LinkedList()\n    que.offer(startVet)\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.isEmpty()) {\n        val vet = que.poll() // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.add(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet)) continue  // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n\n            que.offer(adjVet) // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.rb
    [class]{}-[func]{graph_bfs}\n
    graph_bfs.zig
    [class]{}-[func]{graphBFS}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u4ee3\u7801\u76f8\u5bf9\u62bd\u8c61\uff0c\u5efa\u8bae\u5bf9\u7167\u56fe 9-10 \u6765\u52a0\u6df1\u7406\u89e3\u3002

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

    \u56fe 9-10 \u00a0 \u56fe\u7684\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u6b65\u9aa4

    \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\u5141\u8bb8\u88ab\u4efb\u610f\u6253\u4e71\u3002\u4ee5\u56fe 9-10 \u4e3a\u4f8b\uff0c\u9876\u70b9 \\(1\\)\u3001\\(3\\) \u7684\u8bbf\u95ee\u987a\u5e8f\u53ef\u4ee5\u4ea4\u6362\uff0c\u9876\u70b9 \\(2\\)\u3001\\(4\\)\u3001\\(6\\) \u7684\u8bbf\u95ee\u987a\u5e8f\u4e5f\u53ef\u4ee5\u4efb\u610f\u4ea4\u6362\u3002

    "},{"location":"chapter_graph/graph_traversal/#2","title":"2. \u00a0 \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\u5982\u56fe 9-11 \u6240\u793a\uff0c\u4ece\u5de6\u4e0a\u89d2\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

    \u56fe 9-11 \u00a0 \u56fe\u7684\u6df1\u5ea6\u4f18\u5148\u904d\u5386

    "},{"location":"chapter_graph/graph_traversal/#1_1","title":"1. \u00a0 \u7b97\u6cd5\u5b9e\u73b0","text":"

    \u8fd9\u79cd\u201c\u8d70\u5230\u5c3d\u5934\u518d\u8fd4\u56de\u201d\u7684\u7b97\u6cd5\u8303\u5f0f\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u6765\u5b9e\u73b0\u3002\u4e0e\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u7c7b\u4f3c\uff0c\u5728\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u4e2d\uff0c\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_dfs.py
    def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570\"\"\"\n    res.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    # \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        # \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n    \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\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\n    res = []\n    # \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n
    graph_dfs.cpp
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {\n    res.push_back(vet);   // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.emplace(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    vector<Vertex *> res;\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    unordered_set<Vertex *> visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.java
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {\n    res.add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = new ArrayList<>();\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    Set<Vertex> visited = new HashSet<>();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.cs
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid DFS(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {\n    res.Add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.Add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9                             \n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    HashSet<Vertex> visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.go
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\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)\n    visited[vet] = struct{}{}\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    res := make([]Vertex, 0)\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &res, startVet)\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_dfs.swift
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfunc dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.insert(vet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph: graph, visited: &visited, res: &res, vet: adjVet)\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    var res: [Vertex] = []\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    var visited: Set<Vertex> = []\n    dfs(graph: graph, visited: &visited, res: &res, vet: startVet)\n    return res\n}\n
    graph_dfs.js
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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) {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.ts
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set<Vertex>,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res: Vertex[] = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited: Set<Vertex> = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.dart
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(\n  GraphAdjList graph,\n  Set<Vertex> visited,\n  List<Vertex> res,\n  Vertex vet,\n) {\n  res.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n  visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n  // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n    }\n    // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n  // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n  List<Vertex> res = [];\n  // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n  Set<Vertex> visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n
    graph_dfs.rs
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfn dfs(graph: &GraphAdjList, visited: &mut HashSet<Vertex>, res: &mut Vec<Vertex>, vet: Vertex) {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.insert(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n                         // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    if let Some(adj_vets) = graph.adj_list.get(&vet) {\n        for &adj_vet in adj_vets {\n            if visited.contains(&adj_vet) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    let mut res = vec![];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    let mut visited = HashSet::new();\n    dfs(&graph, &mut visited, &mut res, start_vet);\n\n    res\n}\n
    graph_dfs.c
    /* \u68c0\u67e5\u9876\u70b9\u662f\u5426\u5df2\u88ab\u8bbf\u95ee */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // \u904d\u5386\u67e5\u627e\u8282\u70b9\uff0c\u4f7f\u7528 O(n) \u65f6\u95f4\n    for (int i = 0; i < size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    res[(*resSize)++] = vet;\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        if (!isVisited(res, *resSize, node->vertex)) {\n            // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n            dfs(graph, res, resSize, node->vertex);\n        }\n        node = node->next;\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n
    graph_dfs.kt
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet<Vertex?>,\n    res: MutableList<Vertex?>,\n    vet: Vertex?\n) {\n    res.add(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet)) continue  // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfun graphDFS(\n    graph: GraphAdjList,\n    startVet: Vertex?\n): List<Vertex?> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    val res: MutableList<Vertex?> = ArrayList()\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    val visited: MutableSet<Vertex?> = HashSet()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n
    graph_dfs.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{graph_dfs}\n
    graph_dfs.zig
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{graphDFS}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u7b97\u6cd5\u6d41\u7a0b\u5982\u56fe 9-12 \u6240\u793a\u3002

    • \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\u3002
    • \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\u65b9\u6cd5\u7684\u4f4d\u7f6e\u3002

    \u4e3a\u4e86\u52a0\u6df1\u7406\u89e3\uff0c\u5efa\u8bae\u5c06\u56fe 9-12 \u4e0e\u4ee3\u7801\u7ed3\u5408\u8d77\u6765\uff0c\u5728\u8111\u4e2d\u6a21\u62df\uff08\u6216\u8005\u7528\u7b14\u753b\u4e0b\u6765\uff09\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>

    \u56fe 9-12 \u00a0 \u56fe\u7684\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u6b65\u9aa4

    \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\u201c\u5de6 \\(\\rightarrow\\) \u6839 \\(\\rightarrow\\) \u53f3\u201d\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\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/#2_1","title":"2. \u00a0 \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":""},{"location":"chapter_graph/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","text":"
    • \u56fe\u7531\u9876\u70b9\u548c\u8fb9\u7ec4\u6210\uff0c\u53ef\u4ee5\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\u6539\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\\) \u4e2a\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\u56e0\u6b64\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\u7684\u89d2\u5ea6\u5206\u6790\uff0c\u90bb\u63a5\u77e9\u9635\u4f53\u73b0\u4e86\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\uff0c\u90bb\u63a5\u8868\u4f53\u73b0\u4e86\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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u89c6\u4e3a\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

    Q\uff1a\u975e\u8fde\u901a\u56fe\u4e2d\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

    Q\uff1a\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\u9700\u8981\u6309\u7167\u6307\u5b9a\u89c4\u5219\u6765\u6392\u5e8f\uff0c\u6bd4\u5982\u6309\u7167\u9876\u70b9\u6dfb\u52a0\u7684\u6b21\u5e8f\uff0c\u6216\u8005\u6309\u7167\u9876\u70b9\u503c\u5927\u5c0f\u7684\u987a\u5e8f\u7b49\uff0c\u8fd9\u6837\u6709\u52a9\u4e8e\u5feb\u901f\u67e5\u627e\u201c\u5e26\u6709\u67d0\u79cd\u6781\u503c\u201d\u7684\u9876\u70b9\u3002

    "},{"location":"chapter_greedy/","title":"\u7b2c 15 \u7ae0 \u00a0 \u8d2a\u5fc3","text":"

    Abstract

    \u5411\u65e5\u8475\u671d\u7740\u592a\u9633\u8f6c\u52a8\uff0c\u65f6\u523b\u8ffd\u6c42\u81ea\u8eab\u6210\u957f\u7684\u6700\u5927\u53ef\u80fd\u3002

    \u8d2a\u5fc3\u7b56\u7565\u5728\u4e00\u8f6e\u8f6e\u7684\u7b80\u5355\u9009\u62e9\u4e2d\uff0c\u9010\u6b65\u5bfc\u5411\u6700\u4f73\u7b54\u6848\u3002

    "},{"location":"chapter_greedy/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 15.1 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5
    • 15.2 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898
    • 15.3 \u00a0 \u6700\u5927\u5bb9\u91cf\u95ee\u9898
    • 15.4 \u00a0 \u6700\u5927\u5207\u5206\u4e58\u79ef\u95ee\u9898
    • 15.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_greedy/fractional_knapsack_problem/","title":"15.2 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898","text":"

    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\u548c\u4e00\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\u3002\u6bcf\u4e2a\u7269\u54c1\u53ea\u80fd\u9009\u62e9\u4e00\u6b21\uff0c\u4f46\u53ef\u4ee5\u9009\u62e9\u7269\u54c1\u7684\u4e00\u90e8\u5206\uff0c\u4ef7\u503c\u6839\u636e\u9009\u62e9\u7684\u91cd\u91cf\u6bd4\u4f8b\u8ba1\u7b97\uff0c\u95ee\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u80cc\u5305\u4e2d\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002\u793a\u4f8b\u5982\u56fe 15-3 \u6240\u793a\u3002

    \u56fe 15-3 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    \u5206\u6570\u80cc\u5305\u95ee\u9898\u548c 0-1 \u80cc\u5305\u95ee\u9898\u6574\u4f53\u4e0a\u975e\u5e38\u76f8\u4f3c\uff0c\u72b6\u6001\u5305\u542b\u5f53\u524d\u7269\u54c1 \\(i\\) \u548c\u5bb9\u91cf \\(c\\) \uff0c\u76ee\u6807\u662f\u6c42\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u7684\u6700\u5927\u4ef7\u503c\u3002

    \u4e0d\u540c\u70b9\u5728\u4e8e\uff0c\u672c\u9898\u5141\u8bb8\u53ea\u9009\u62e9\u7269\u54c1\u7684\u4e00\u90e8\u5206\u3002\u5982\u56fe 15-4 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5bf9\u7269\u54c1\u4efb\u610f\u5730\u8fdb\u884c\u5207\u5206\uff0c\u5e76\u6309\u7167\u91cd\u91cf\u6bd4\u4f8b\u6765\u8ba1\u7b97\u76f8\u5e94\u4ef7\u503c\u3002

    1. \u5bf9\u4e8e\u7269\u54c1 \\(i\\) \uff0c\u5b83\u5728\u5355\u4f4d\u91cd\u91cf\u4e0b\u7684\u4ef7\u503c\u4e3a \\(val[i-1] / wgt[i-1]\\) \uff0c\u7b80\u79f0\u5355\u4f4d\u4ef7\u503c\u3002
    2. \u5047\u8bbe\u653e\u5165\u4e00\u90e8\u5206\u7269\u54c1 \\(i\\) \uff0c\u91cd\u91cf\u4e3a \\(w\\) \uff0c\u5219\u80cc\u5305\u589e\u52a0\u7684\u4ef7\u503c\u4e3a \\(w \\times val[i-1] / wgt[i-1]\\) \u3002

    \u56fe 15-4 \u00a0 \u7269\u54c1\u5728\u5355\u4f4d\u91cd\u91cf\u4e0b\u7684\u4ef7\u503c

    "},{"location":"chapter_greedy/fractional_knapsack_problem/#1","title":"1. \u00a0 \u8d2a\u5fc3\u7b56\u7565\u786e\u5b9a","text":"

    \u6700\u5927\u5316\u80cc\u5305\u5185\u7269\u54c1\u603b\u4ef7\u503c\uff0c\u672c\u8d28\u4e0a\u662f\u6700\u5927\u5316\u5355\u4f4d\u91cd\u91cf\u4e0b\u7684\u7269\u54c1\u4ef7\u503c\u3002\u7531\u6b64\u4fbf\u53ef\u63a8\u7406\u51fa\u56fe 15-5 \u6240\u793a\u7684\u8d2a\u5fc3\u7b56\u7565\u3002

    1. \u5c06\u7269\u54c1\u6309\u7167\u5355\u4f4d\u4ef7\u503c\u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\u3002
    2. \u904d\u5386\u6240\u6709\u7269\u54c1\uff0c\u6bcf\u8f6e\u8d2a\u5fc3\u5730\u9009\u62e9\u5355\u4f4d\u4ef7\u503c\u6700\u9ad8\u7684\u7269\u54c1\u3002
    3. \u82e5\u5269\u4f59\u80cc\u5305\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u4f7f\u7528\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u586b\u6ee1\u80cc\u5305\u3002

    \u56fe 15-5 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898\u7684\u8d2a\u5fc3\u7b56\u7565

    "},{"location":"chapter_greedy/fractional_knapsack_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u6211\u4eec\u5efa\u7acb\u4e86\u4e00\u4e2a\u7269\u54c1\u7c7b Item \uff0c\u4ee5\u4fbf\u5c06\u7269\u54c1\u6309\u7167\u5355\u4f4d\u4ef7\u503c\u8fdb\u884c\u6392\u5e8f\u3002\u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u5f53\u80cc\u5305\u5df2\u6ee1\u65f6\u8df3\u51fa\u5e76\u8fd4\u56de\u89e3\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig fractional_knapsack.py
    class Item:\n    \"\"\"\u7269\u54c1\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # \u7269\u54c1\u91cd\u91cf\n        self.v = v  # \u7269\u54c1\u4ef7\u503c\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -> int:\n    \"\"\"\u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3\"\"\"\n    # \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    res = 0\n    for item in items:\n        if item.w <= cap:\n            # \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v\n            cap -= item.w\n        else:\n            # \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (item.v / item.w) * cap\n            # \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n    return res\n
    fractional_knapsack.cpp
    /* \u7269\u54c1 */\nclass Item {\n  public:\n    int w; // \u7269\u54c1\u91cd\u91cf\n    int v; // \u7269\u54c1\u4ef7\u503c\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\ndouble fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    vector<Item> items;\n    for (int i = 0; i < wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    double res = 0;\n    for (auto &item : items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (double)item.v / item.w * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.java
    /* \u7269\u54c1 */\nclass Item {\n    int w; // \u7269\u54c1\u91cd\u91cf\n    int v; // \u7269\u54c1\u4ef7\u503c\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i < wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    Arrays.sort(items, Comparator.comparingDouble(item -> -((double) item.v / item.w)));\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    double res = 0;\n    for (Item item : items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (double) item.v / item.w * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.cs
    /* \u7269\u54c1 */\nclass Item(int w, int v) {\n    public int w = w; // \u7269\u54c1\u91cd\u91cf\n    public int v = v; // \u7269\u54c1\u4ef7\u503c\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i < wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    Array.Sort(items, (x, y) => (y.v / y.w).CompareTo(x.v / x.w));\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (double)item.v / item.w * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.go
    /* \u7269\u54c1 */\ntype Item struct {\n    w int // \u7269\u54c1\u91cd\u91cf\n    v int // \u7269\u54c1\u4ef7\u503c\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    items := make([]Item, len(wgt))\n    for i := 0; i < len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) > float64(items[j].v)/float64(items[j].w)\n    })\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    res := 0.0\n    for _, item := range items {\n        if item.w <= cap {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    return res\n}\n
    fractional_knapsack.swift
    /* \u7269\u54c1 */\nclass Item {\n    var w: Int // \u7269\u54c1\u91cd\u91cf\n    var v: Int // \u7269\u54c1\u4ef7\u503c\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -> Double {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort { -(Double($0.v) / Double($0.w)) < -(Double($1.v) / Double($1.w)) }\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w <= cap {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    return res\n}\n
    fractional_knapsack.js
    /* \u7269\u54c1 */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // \u7269\u54c1\u91cd\u91cf\n        this.v = v; // \u7269\u54c1\u4ef7\u503c\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    const items = wgt.map((w, i) => new Item(w, val[i]));\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort((a, b) => b.v / b.w - a.v / a.w);\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    let res = 0;\n    for (const item of items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (item.v / item.w) * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.ts
    /* \u7269\u54c1 */\nclass Item {\n    w: number; // \u7269\u54c1\u91cd\u91cf\n    v: number; // \u7269\u54c1\u4ef7\u503c\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    const items: Item[] = wgt.map((w, i) => new Item(w, val[i]));\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort((a, b) => b.v / b.w - a.v / a.w);\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    let res = 0;\n    for (const item of items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (item.v / item.w) * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.dart
    /* \u7269\u54c1 */\nclass Item {\n  int w; // \u7269\u54c1\u91cd\u91cf\n  int v; // \u7269\u54c1\u4ef7\u503c\n\n  Item(this.w, this.v);\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\ndouble fractionalKnapsack(List<int> wgt, List<int> val, int cap) {\n  // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n  List<Item> items = List.generate(wgt.length, (i) => Item(wgt[i], val[i]));\n  // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n  items.sort((a, b) => (b.v / b.w).compareTo(a.v / a.w));\n  // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n  double res = 0;\n  for (Item item in items) {\n    if (item.w <= cap) {\n      // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n      res += item.v / item.w * cap;\n      // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n      break;\n    }\n  }\n  return res;\n}\n
    fractional_knapsack.rs
    /* \u7269\u54c1 */\nstruct Item {\n    w: i32, // \u7269\u54c1\u91cd\u91cf\n    v: i32, // \u7269\u54c1\u4ef7\u503c\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -> Self {\n        Self { w, v }\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfn fractional_knapsack(wgt: &[i32], val: &[i32], mut cap: i32) -> f64 {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&w, &v)| Item::new(w, v))\n        .collect::<Vec<Item>>();\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    let mut res = 0.0;\n    for item in &items {\n        if item.w <= cap {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    res\n}\n
    fractional_knapsack.c
    /* \u7269\u54c1 */\ntypedef struct {\n    int w; // \u7269\u54c1\u91cd\u91cf\n    int v; // \u7269\u54c1\u4ef7\u503c\n} Item;\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i < itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    float res = 0.0;\n    for (int i = 0; i < itemCount; i++) {\n        if (items[i].w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n
    fractional_knapsack.kt
    /* \u7269\u54c1 */\nclass Item(\n    val w: Int, // \u7269\u54c1\n    val v: Int // \u7269\u54c1\u4ef7\u503c\n)\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfun fractionalKnapsack(\n    wgt: IntArray,\n    value: IntArray,\n    c: Int\n): Double {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    var cap = c\n    val items = arrayOfNulls<Item>(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], value[i])\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    Arrays.sort(items, Comparator.comparingDouble { item: Item -> -(item.v.toDouble() / item.w) })\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v.toDouble()\n            cap -= item.w\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += item.v.toDouble() / item.w * cap\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    return res\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfun fractionalKnapsack(\n    wgt: IntArray,\n    value: IntArray,\n    c: Int\n): Double {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    var cap = c\n    val items = arrayOfNulls<Item>(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], value[i])\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    Arrays.sort(items, Comparator.comparingDouble { item: Item -> -(item.v.toDouble() / item.w) })\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v.toDouble()\n            cap -= item.w\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += item.v.toDouble() / item.w * cap\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    return res\n}\n
    fractional_knapsack.rb
    [class]{Item}-[func]{}\n\n[class]{}-[func]{fractional_knapsack}\n
    fractional_knapsack.zig
    [class]{Item}-[func]{}\n\n[class]{}-[func]{fractionalKnapsack}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u9664\u6392\u5e8f\u4e4b\u5916\uff0c\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u9700\u8981\u904d\u5386\u6574\u4e2a\u7269\u54c1\u5217\u8868\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5176\u4e2d \\(n\\) \u4e3a\u7269\u54c1\u6570\u91cf\u3002

    \u7531\u4e8e\u521d\u59cb\u5316\u4e86\u4e00\u4e2a Item \u5bf9\u8c61\u5217\u8868\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    "},{"location":"chapter_greedy/fractional_knapsack_problem/#3","title":"3. \u00a0 \u6b63\u786e\u6027\u8bc1\u660e","text":"

    \u91c7\u7528\u53cd\u8bc1\u6cd5\u3002\u5047\u8bbe\u7269\u54c1 \\(x\\) \u662f\u5355\u4f4d\u4ef7\u503c\u6700\u9ad8\u7684\u7269\u54c1\uff0c\u4f7f\u7528\u67d0\u7b97\u6cd5\u6c42\u5f97\u6700\u5927\u4ef7\u503c\u4e3a res \uff0c\u4f46\u8be5\u89e3\u4e2d\u4e0d\u5305\u542b\u7269\u54c1 \\(x\\) \u3002

    \u73b0\u5728\u4ece\u80cc\u5305\u4e2d\u62ff\u51fa\u5355\u4f4d\u91cd\u91cf\u7684\u4efb\u610f\u7269\u54c1\uff0c\u5e76\u66ff\u6362\u4e3a\u5355\u4f4d\u91cd\u91cf\u7684\u7269\u54c1 \\(x\\) \u3002\u7531\u4e8e\u7269\u54c1 \\(x\\) \u7684\u5355\u4f4d\u4ef7\u503c\u6700\u9ad8\uff0c\u56e0\u6b64\u66ff\u6362\u540e\u7684\u603b\u4ef7\u503c\u4e00\u5b9a\u5927\u4e8e res \u3002\u8fd9\u4e0e res \u662f\u6700\u4f18\u89e3\u77db\u76fe\uff0c\u8bf4\u660e\u6700\u4f18\u89e3\u4e2d\u5fc5\u987b\u5305\u542b\u7269\u54c1 \\(x\\) \u3002

    \u5bf9\u4e8e\u8be5\u89e3\u4e2d\u7684\u5176\u4ed6\u7269\u54c1\uff0c\u6211\u4eec\u4e5f\u53ef\u4ee5\u6784\u5efa\u51fa\u4e0a\u8ff0\u77db\u76fe\u3002\u603b\u800c\u8a00\u4e4b\uff0c\u5355\u4f4d\u4ef7\u503c\u66f4\u5927\u7684\u7269\u54c1\u603b\u662f\u66f4\u4f18\u9009\u62e9\uff0c\u8fd9\u8bf4\u660e\u8d2a\u5fc3\u7b56\u7565\u662f\u6709\u6548\u7684\u3002

    \u5982\u56fe 15-6 \u6240\u793a\uff0c\u5982\u679c\u5c06\u7269\u54c1\u91cd\u91cf\u548c\u7269\u54c1\u5355\u4f4d\u4ef7\u503c\u5206\u522b\u770b\u4f5c\u4e00\u5f20\u4e8c\u7ef4\u56fe\u8868\u7684\u6a2a\u8f74\u548c\u7eb5\u8f74\uff0c\u5219\u5206\u6570\u80cc\u5305\u95ee\u9898\u53ef\u8f6c\u5316\u4e3a\u201c\u6c42\u5728\u6709\u9650\u6a2a\u8f74\u533a\u95f4\u4e0b\u56f4\u6210\u7684\u6700\u5927\u9762\u79ef\u201d\u3002\u8fd9\u4e2a\u7c7b\u6bd4\u53ef\u4ee5\u5e2e\u52a9\u6211\u4eec\u4ece\u51e0\u4f55\u89d2\u5ea6\u7406\u89e3\u8d2a\u5fc3\u7b56\u7565\u7684\u6709\u6548\u6027\u3002

    \u56fe 15-6 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898\u7684\u51e0\u4f55\u8868\u793a

    "},{"location":"chapter_greedy/greedy_algorithm/","title":"15.1 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5","text":"

    \u300c\u8d2a\u5fc3\u7b97\u6cd5 greedy algorithm\u300d\u662f\u4e00\u79cd\u5e38\u89c1\u7684\u89e3\u51b3\u4f18\u5316\u95ee\u9898\u7684\u7b97\u6cd5\uff0c\u5176\u57fa\u672c\u601d\u60f3\u662f\u5728\u95ee\u9898\u7684\u6bcf\u4e2a\u51b3\u7b56\u9636\u6bb5\uff0c\u90fd\u9009\u62e9\u5f53\u524d\u770b\u8d77\u6765\u6700\u4f18\u7684\u9009\u62e9\uff0c\u5373\u8d2a\u5fc3\u5730\u505a\u51fa\u5c40\u90e8\u6700\u4f18\u7684\u51b3\u7b56\uff0c\u4ee5\u671f\u83b7\u5f97\u5168\u5c40\u6700\u4f18\u89e3\u3002\u8d2a\u5fc3\u7b97\u6cd5\u7b80\u6d01\u4e14\u9ad8\u6548\uff0c\u5728\u8bb8\u591a\u5b9e\u9645\u95ee\u9898\u4e2d\u6709\u7740\u5e7f\u6cdb\u7684\u5e94\u7528\u3002

    \u8d2a\u5fc3\u7b97\u6cd5\u548c\u52a8\u6001\u89c4\u5212\u90fd\u5e38\u7528\u4e8e\u89e3\u51b3\u4f18\u5316\u95ee\u9898\u3002\u5b83\u4eec\u4e4b\u95f4\u5b58\u5728\u4e00\u4e9b\u76f8\u4f3c\u4e4b\u5904\uff0c\u6bd4\u5982\u90fd\u4f9d\u8d56\u6700\u4f18\u5b50\u7ed3\u6784\u6027\u8d28\uff0c\u4f46\u5de5\u4f5c\u539f\u7406\u4e0d\u540c\u3002

    • \u52a8\u6001\u89c4\u5212\u4f1a\u6839\u636e\u4e4b\u524d\u9636\u6bb5\u7684\u6240\u6709\u51b3\u7b56\u6765\u8003\u8651\u5f53\u524d\u51b3\u7b56\uff0c\u5e76\u4f7f\u7528\u8fc7\u53bb\u5b50\u95ee\u9898\u7684\u89e3\u6765\u6784\u5efa\u5f53\u524d\u5b50\u95ee\u9898\u7684\u89e3\u3002
    • \u8d2a\u5fc3\u7b97\u6cd5\u4e0d\u4f1a\u8003\u8651\u8fc7\u53bb\u7684\u51b3\u7b56\uff0c\u800c\u662f\u4e00\u8def\u5411\u524d\u5730\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u4e0d\u65ad\u7f29\u5c0f\u95ee\u9898\u8303\u56f4\uff0c\u76f4\u81f3\u95ee\u9898\u88ab\u89e3\u51b3\u3002

    \u6211\u4eec\u5148\u901a\u8fc7\u4f8b\u9898\u201c\u96f6\u94b1\u5151\u6362\u201d\u4e86\u89e3\u8d2a\u5fc3\u7b97\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u3002\u8fd9\u9053\u9898\u5df2\u7ecf\u5728\u201c\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u201d\u7ae0\u8282\u4e2d\u4ecb\u7ecd\u8fc7\uff0c\u76f8\u4fe1\u4f60\u5bf9\u5b83\u5e76\u4e0d\u964c\u751f\u3002

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u786c\u5e01\uff0c\u7b2c \\(i\\) \u79cd\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\u80fd\u591f\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u7684\u6700\u5c11\u786c\u5e01\u6570\u91cf\u3002\u5982\u679c\u65e0\u6cd5\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002

    \u672c\u9898\u91c7\u53d6\u7684\u8d2a\u5fc3\u7b56\u7565\u5982\u56fe 15-1 \u6240\u793a\u3002\u7ed9\u5b9a\u76ee\u6807\u91d1\u989d\uff0c\u6211\u4eec\u8d2a\u5fc3\u5730\u9009\u62e9\u4e0d\u5927\u4e8e\u4e14\u6700\u63a5\u8fd1\u5b83\u7684\u786c\u5e01\uff0c\u4e0d\u65ad\u5faa\u73af\u8be5\u6b65\u9aa4\uff0c\u76f4\u81f3\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u4e3a\u6b62\u3002

    \u56fe 15-1 \u00a0 \u96f6\u94b1\u5151\u6362\u7684\u8d2a\u5fc3\u7b56\u7565

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig coin_change_greedy.py
    def coin_change_greedy(coins: list[int], amt: int) -> int:\n    \"\"\"\u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3\"\"\"\n    # \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    i = len(coins) - 1\n    count = 0\n    # \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while amt > 0:\n        # \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while i > 0 and coins[i] > amt:\n            i -= 1\n        # \u9009\u62e9 coins[i]\n        amt -= coins[i]\n        count += 1\n    # \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return count if amt == 0 else -1\n
    coin_change_greedy.cpp
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint coinChangeGreedy(vector<int> &coins, int amt) {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    int i = coins.size() - 1;\n    int count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.java
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint coinChangeGreedy(int[] coins, int amt) {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    int i = coins.length - 1;\n    int count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.cs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    int i = coins.Length - 1;\n    int count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.go
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    i := len(coins) - 1\n    count := 0\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    for amt > 0 {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        for i > 0 && coins[i] > amt {\n            i--\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i]\n        count++\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n
    coin_change_greedy.swift
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -> Int {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while amt > 0 {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while i > 0 && coins[i] > amt {\n            i -= 1\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i]\n        count += 1\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1\n}\n
    coin_change_greedy.js
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfunction coinChangeGreedy(coins, amt) {\n    // \u5047\u8bbe coins \u6570\u7ec4\u6709\u5e8f\n    let i = coins.length - 1;\n    let count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt === 0 ? count : -1;\n}\n
    coin_change_greedy.ts
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // \u5047\u8bbe coins \u6570\u7ec4\u6709\u5e8f\n    let i = coins.length - 1;\n    let count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt === 0 ? count : -1;\n}\n
    coin_change_greedy.dart
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint coinChangeGreedy(List<int> coins, int amt) {\n  // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n  int i = coins.length - 1;\n  int count = 0;\n  // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n  while (amt > 0) {\n    // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n    while (i > 0 && coins[i] > amt) {\n      i--;\n    }\n    // \u9009\u62e9 coins[i]\n    amt -= coins[i];\n    count++;\n  }\n  // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n  return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.rs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfn coin_change_greedy(coins: &[i32], mut amt: i32) -> i32 {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while amt > 0 {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while i > 0 && coins[i] > amt {\n            i -= 1;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count += 1;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n
    coin_change_greedy.c
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    int i = size - 1;\n    int count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.kt
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (am > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > am) {\n            i--\n        }\n        // \u9009\u62e9 coins[i]\n        am -= coins[i]\n        count++\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return if (am == 0) count else -1\n}\n
    coin_change_greedy.rb
    [class]{}-[func]{coin_change_greedy}\n
    coin_change_greedy.zig
    [class]{}-[func]{coinChangeGreedy}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u4f60\u53ef\u80fd\u4f1a\u4e0d\u7531\u5730\u53d1\u51fa\u611f\u53f9\uff1aSo clean \uff01\u8d2a\u5fc3\u7b97\u6cd5\u4ec5\u7528\u7ea6\u5341\u884c\u4ee3\u7801\u5c31\u89e3\u51b3\u4e86\u96f6\u94b1\u5151\u6362\u95ee\u9898\u3002

    "},{"location":"chapter_greedy/greedy_algorithm/#1511","title":"15.1.1 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u7684\u4f18\u70b9\u4e0e\u5c40\u9650\u6027","text":"

    \u8d2a\u5fc3\u7b97\u6cd5\u4e0d\u4ec5\u64cd\u4f5c\u76f4\u63a5\u3001\u5b9e\u73b0\u7b80\u5355\uff0c\u800c\u4e14\u901a\u5e38\u6548\u7387\u4e5f\u5f88\u9ad8\u3002\u5728\u4ee5\u4e0a\u4ee3\u7801\u4e2d\uff0c\u8bb0\u786c\u5e01\u6700\u5c0f\u9762\u503c\u4e3a \\(\\min(coins)\\) \uff0c\u5219\u8d2a\u5fc3\u9009\u62e9\u6700\u591a\u5faa\u73af \\(amt / \\min(coins)\\) \u6b21\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(amt / \\min(coins))\\) \u3002\u8fd9\u6bd4\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n \\times amt)\\) \u5c0f\u4e86\u4e00\u4e2a\u6570\u91cf\u7ea7\u3002

    \u7136\u800c\uff0c\u5bf9\u4e8e\u67d0\u4e9b\u786c\u5e01\u9762\u503c\u7ec4\u5408\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u5e76\u4e0d\u80fd\u627e\u5230\u6700\u4f18\u89e3\u3002\u56fe 15-2 \u7ed9\u51fa\u4e86\u4e24\u4e2a\u793a\u4f8b\u3002

    • \u6b63\u4f8b \\(coins = [1, 5, 10, 20, 50, 100]\\)\uff1a\u5728\u8be5\u786c\u5e01\u7ec4\u5408\u4e0b\uff0c\u7ed9\u5b9a\u4efb\u610f \\(amt\\) \uff0c\u8d2a\u5fc3\u7b97\u6cd5\u90fd\u53ef\u4ee5\u627e\u5230\u6700\u4f18\u89e3\u3002
    • \u53cd\u4f8b \\(coins = [1, 20, 50]\\)\uff1a\u5047\u8bbe \\(amt = 60\\) \uff0c\u8d2a\u5fc3\u7b97\u6cd5\u53ea\u80fd\u627e\u5230 \\(50 + 1 \\times 10\\) \u7684\u5151\u6362\u7ec4\u5408\uff0c\u5171\u8ba1 \\(11\\) \u679a\u786c\u5e01\uff0c\u4f46\u52a8\u6001\u89c4\u5212\u53ef\u4ee5\u627e\u5230\u6700\u4f18\u89e3 \\(20 + 20 + 20\\) \uff0c\u4ec5\u9700 \\(3\\) \u679a\u786c\u5e01\u3002
    • \u53cd\u4f8b \\(coins = [1, 49, 50]\\)\uff1a\u5047\u8bbe \\(amt = 98\\) \uff0c\u8d2a\u5fc3\u7b97\u6cd5\u53ea\u80fd\u627e\u5230 \\(50 + 1 \\times 48\\) \u7684\u5151\u6362\u7ec4\u5408\uff0c\u5171\u8ba1 \\(49\\) \u679a\u786c\u5e01\uff0c\u4f46\u52a8\u6001\u89c4\u5212\u53ef\u4ee5\u627e\u5230\u6700\u4f18\u89e3 \\(49 + 49\\) \uff0c\u4ec5\u9700 \\(2\\) \u679a\u786c\u5e01\u3002

    \u56fe 15-2 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u65e0\u6cd5\u627e\u51fa\u6700\u4f18\u89e3\u7684\u793a\u4f8b

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5bf9\u4e8e\u96f6\u94b1\u5151\u6362\u95ee\u9898\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u65e0\u6cd5\u4fdd\u8bc1\u627e\u5230\u5168\u5c40\u6700\u4f18\u89e3\uff0c\u5e76\u4e14\u6709\u53ef\u80fd\u627e\u5230\u975e\u5e38\u5dee\u7684\u89e3\u3002\u5b83\u66f4\u9002\u5408\u7528\u52a8\u6001\u89c4\u5212\u89e3\u51b3\u3002

    \u4e00\u822c\u60c5\u51b5\u4e0b\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u7684\u9002\u7528\u60c5\u51b5\u5206\u4ee5\u4e0b\u4e24\u79cd\u3002

    1. \u53ef\u4ee5\u4fdd\u8bc1\u627e\u5230\u6700\u4f18\u89e3\uff1a\u8d2a\u5fc3\u7b97\u6cd5\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\u5f80\u5f80\u662f\u6700\u4f18\u9009\u62e9\uff0c\u56e0\u4e3a\u5b83\u5f80\u5f80\u6bd4\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\u66f4\u9ad8\u6548\u3002
    2. \u53ef\u4ee5\u627e\u5230\u8fd1\u4f3c\u6700\u4f18\u89e3\uff1a\u8d2a\u5fc3\u7b97\u6cd5\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\u4e5f\u662f\u53ef\u7528\u7684\u3002\u5bf9\u4e8e\u5f88\u591a\u590d\u6742\u95ee\u9898\u6765\u8bf4\uff0c\u5bfb\u627e\u5168\u5c40\u6700\u4f18\u89e3\u975e\u5e38\u56f0\u96be\uff0c\u80fd\u4ee5\u8f83\u9ad8\u6548\u7387\u627e\u5230\u6b21\u4f18\u89e3\u4e5f\u662f\u975e\u5e38\u4e0d\u9519\u7684\u3002
    "},{"location":"chapter_greedy/greedy_algorithm/#1512","title":"15.1.2 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u7279\u6027","text":"

    \u90a3\u4e48\u95ee\u9898\u6765\u4e86\uff0c\u4ec0\u4e48\u6837\u7684\u95ee\u9898\u9002\u5408\u7528\u8d2a\u5fc3\u7b97\u6cd5\u6c42\u89e3\u5462\uff1f\u6216\u8005\u8bf4\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u5728\u4ec0\u4e48\u60c5\u51b5\u4e0b\u53ef\u4ee5\u4fdd\u8bc1\u627e\u5230\u6700\u4f18\u89e3\uff1f

    \u76f8\u8f83\u4e8e\u52a8\u6001\u89c4\u5212\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u7684\u4f7f\u7528\u6761\u4ef6\u66f4\u52a0\u82db\u523b\uff0c\u5176\u4e3b\u8981\u5173\u6ce8\u95ee\u9898\u7684\u4e24\u4e2a\u6027\u8d28\u3002

    • \u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\uff1a\u53ea\u6709\u5f53\u5c40\u90e8\u6700\u4f18\u9009\u62e9\u59cb\u7ec8\u53ef\u4ee5\u5bfc\u81f4\u5168\u5c40\u6700\u4f18\u89e3\u65f6\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u624d\u80fd\u4fdd\u8bc1\u5f97\u5230\u6700\u4f18\u89e3\u3002
    • \u6700\u4f18\u5b50\u7ed3\u6784\uff1a\u539f\u95ee\u9898\u7684\u6700\u4f18\u89e3\u5305\u542b\u5b50\u95ee\u9898\u7684\u6700\u4f18\u89e3\u3002

    \u6700\u4f18\u5b50\u7ed3\u6784\u5df2\u7ecf\u5728\u201c\u52a8\u6001\u89c4\u5212\u201d\u7ae0\u8282\u4e2d\u4ecb\u7ecd\u8fc7\uff0c\u8fd9\u91cc\u4e0d\u518d\u8d58\u8ff0\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u4e00\u4e9b\u95ee\u9898\u7684\u6700\u4f18\u5b50\u7ed3\u6784\u5e76\u4e0d\u660e\u663e\uff0c\u4f46\u4ecd\u7136\u53ef\u4f7f\u7528\u8d2a\u5fc3\u7b97\u6cd5\u89e3\u51b3\u3002

    \u6211\u4eec\u4e3b\u8981\u63a2\u7a76\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u7684\u5224\u65ad\u65b9\u6cd5\u3002\u867d\u7136\u5b83\u7684\u63cf\u8ff0\u770b\u4e0a\u53bb\u6bd4\u8f83\u7b80\u5355\uff0c\u4f46\u5b9e\u9645\u4e0a\u5bf9\u4e8e\u8bb8\u591a\u95ee\u9898\uff0c\u8bc1\u660e\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u5e76\u975e\u6613\u4e8b\u3002

    \u4f8b\u5982\u96f6\u94b1\u5151\u6362\u95ee\u9898\uff0c\u6211\u4eec\u867d\u7136\u80fd\u591f\u5bb9\u6613\u5730\u4e3e\u51fa\u53cd\u4f8b\uff0c\u5bf9\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u8fdb\u884c\u8bc1\u4f2a\uff0c\u4f46\u8bc1\u5b9e\u7684\u96be\u5ea6\u8f83\u5927\u3002\u5982\u679c\u95ee\uff1a\u6ee1\u8db3\u4ec0\u4e48\u6761\u4ef6\u7684\u786c\u5e01\u7ec4\u5408\u53ef\u4ee5\u4f7f\u7528\u8d2a\u5fc3\u7b97\u6cd5\u6c42\u89e3\uff1f\u6211\u4eec\u5f80\u5f80\u53ea\u80fd\u51ed\u501f\u76f4\u89c9\u6216\u4e3e\u4f8b\u5b50\u6765\u7ed9\u51fa\u4e00\u4e2a\u6a21\u68f1\u4e24\u53ef\u7684\u7b54\u6848\uff0c\u800c\u96be\u4ee5\u7ed9\u51fa\u4e25\u8c28\u7684\u6570\u5b66\u8bc1\u660e\u3002

    Quote

    \u6709\u4e00\u7bc7\u8bba\u6587\u7ed9\u51fa\u4e86\u4e00\u4e2a \\(O(n^3)\\) \u65f6\u95f4\u590d\u6742\u5ea6\u7684\u7b97\u6cd5\uff0c\u7528\u4e8e\u5224\u65ad\u4e00\u4e2a\u786c\u5e01\u7ec4\u5408\u80fd\u5426\u4f7f\u7528\u8d2a\u5fc3\u7b97\u6cd5\u627e\u51fa\u4efb\u610f\u91d1\u989d\u7684\u6700\u4f18\u89e3\u3002

    Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.

    "},{"location":"chapter_greedy/greedy_algorithm/#1513","title":"15.1.3 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u89e3\u9898\u6b65\u9aa4","text":"

    \u8d2a\u5fc3\u95ee\u9898\u7684\u89e3\u51b3\u6d41\u7a0b\u5927\u4f53\u53ef\u5206\u4e3a\u4ee5\u4e0b\u4e09\u6b65\u3002

    1. \u95ee\u9898\u5206\u6790\uff1a\u68b3\u7406\u4e0e\u7406\u89e3\u95ee\u9898\u7279\u6027\uff0c\u5305\u62ec\u72b6\u6001\u5b9a\u4e49\u3001\u4f18\u5316\u76ee\u6807\u548c\u7ea6\u675f\u6761\u4ef6\u7b49\u3002\u8fd9\u4e00\u6b65\u5728\u56de\u6eaf\u548c\u52a8\u6001\u89c4\u5212\u4e2d\u90fd\u6709\u6d89\u53ca\u3002
    2. \u786e\u5b9a\u8d2a\u5fc3\u7b56\u7565\uff1a\u786e\u5b9a\u5982\u4f55\u5728\u6bcf\u4e00\u6b65\u4e2d\u505a\u51fa\u8d2a\u5fc3\u9009\u62e9\u3002\u8fd9\u4e2a\u7b56\u7565\u80fd\u591f\u5728\u6bcf\u4e00\u6b65\u51cf\u5c0f\u95ee\u9898\u7684\u89c4\u6a21\uff0c\u5e76\u6700\u7ec8\u89e3\u51b3\u6574\u4e2a\u95ee\u9898\u3002
    3. \u6b63\u786e\u6027\u8bc1\u660e\uff1a\u901a\u5e38\u9700\u8981\u8bc1\u660e\u95ee\u9898\u5177\u6709\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u548c\u6700\u4f18\u5b50\u7ed3\u6784\u3002\u8fd9\u4e2a\u6b65\u9aa4\u53ef\u80fd\u9700\u8981\u7528\u5230\u6570\u5b66\u8bc1\u660e\uff0c\u4f8b\u5982\u5f52\u7eb3\u6cd5\u6216\u53cd\u8bc1\u6cd5\u7b49\u3002

    \u786e\u5b9a\u8d2a\u5fc3\u7b56\u7565\u662f\u6c42\u89e3\u95ee\u9898\u7684\u6838\u5fc3\u6b65\u9aa4\uff0c\u4f46\u5b9e\u65bd\u8d77\u6765\u53ef\u80fd\u5e76\u4e0d\u5bb9\u6613\uff0c\u4e3b\u8981\u6709\u4ee5\u4e0b\u539f\u56e0\u3002

    • \u4e0d\u540c\u95ee\u9898\u7684\u8d2a\u5fc3\u7b56\u7565\u7684\u5dee\u5f02\u8f83\u5927\u3002\u5bf9\u4e8e\u8bb8\u591a\u95ee\u9898\u6765\u8bf4\uff0c\u8d2a\u5fc3\u7b56\u7565\u6bd4\u8f83\u6d45\u663e\uff0c\u6211\u4eec\u901a\u8fc7\u4e00\u4e9b\u5927\u6982\u7684\u601d\u8003\u4e0e\u5c1d\u8bd5\u5c31\u80fd\u5f97\u51fa\u3002\u800c\u5bf9\u4e8e\u4e00\u4e9b\u590d\u6742\u95ee\u9898\uff0c\u8d2a\u5fc3\u7b56\u7565\u53ef\u80fd\u975e\u5e38\u9690\u853d\uff0c\u8fd9\u79cd\u60c5\u51b5\u5c31\u975e\u5e38\u8003\u9a8c\u4e2a\u4eba\u7684\u89e3\u9898\u7ecf\u9a8c\u4e0e\u7b97\u6cd5\u80fd\u529b\u4e86\u3002
    • \u67d0\u4e9b\u8d2a\u5fc3\u7b56\u7565\u5177\u6709\u8f83\u5f3a\u7684\u8ff7\u60d1\u6027\u3002\u5f53\u6211\u4eec\u6ee1\u6000\u4fe1\u5fc3\u8bbe\u8ba1\u597d\u8d2a\u5fc3\u7b56\u7565\uff0c\u5199\u51fa\u89e3\u9898\u4ee3\u7801\u5e76\u63d0\u4ea4\u8fd0\u884c\uff0c\u5f88\u53ef\u80fd\u53d1\u73b0\u90e8\u5206\u6d4b\u8bd5\u6837\u4f8b\u65e0\u6cd5\u901a\u8fc7\u3002\u8fd9\u662f\u56e0\u4e3a\u8bbe\u8ba1\u7684\u8d2a\u5fc3\u7b56\u7565\u53ea\u662f\u201c\u90e8\u5206\u6b63\u786e\u201d\u7684\uff0c\u4e0a\u6587\u4ecb\u7ecd\u7684\u96f6\u94b1\u5151\u6362\u5c31\u662f\u4e00\u4e2a\u5178\u578b\u6848\u4f8b\u3002

    \u4e3a\u4e86\u4fdd\u8bc1\u6b63\u786e\u6027\uff0c\u6211\u4eec\u5e94\u8be5\u5bf9\u8d2a\u5fc3\u7b56\u7565\u8fdb\u884c\u4e25\u8c28\u7684\u6570\u5b66\u8bc1\u660e\uff0c\u901a\u5e38\u9700\u8981\u7528\u5230\u53cd\u8bc1\u6cd5\u6216\u6570\u5b66\u5f52\u7eb3\u6cd5\u3002

    \u7136\u800c\uff0c\u6b63\u786e\u6027\u8bc1\u660e\u4e5f\u5f88\u53ef\u80fd\u4e0d\u662f\u4e00\u4ef6\u6613\u4e8b\u3002\u5982\u82e5\u6ca1\u6709\u5934\u7eea\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u9009\u62e9\u9762\u5411\u6d4b\u8bd5\u7528\u4f8b\u8fdb\u884c\u4ee3\u7801\u8c03\u8bd5\uff0c\u4e00\u6b65\u6b65\u4fee\u6539\u4e0e\u9a8c\u8bc1\u8d2a\u5fc3\u7b56\u7565\u3002

    "},{"location":"chapter_greedy/greedy_algorithm/#1514","title":"15.1.4 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u5178\u578b\u4f8b\u9898","text":"

    \u8d2a\u5fc3\u7b97\u6cd5\u5e38\u5e38\u5e94\u7528\u5728\u6ee1\u8db3\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u548c\u6700\u4f18\u5b50\u7ed3\u6784\u7684\u4f18\u5316\u95ee\u9898\u4e2d\uff0c\u4ee5\u4e0b\u5217\u4e3e\u4e86\u4e00\u4e9b\u5178\u578b\u7684\u8d2a\u5fc3\u7b97\u6cd5\u95ee\u9898\u3002

    • \u786c\u5e01\u627e\u96f6\u95ee\u9898\uff1a\u5728\u67d0\u4e9b\u786c\u5e01\u7ec4\u5408\u4e0b\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u603b\u662f\u53ef\u4ee5\u5f97\u5230\u6700\u4f18\u89e3\u3002
    • \u533a\u95f4\u8c03\u5ea6\u95ee\u9898\uff1a\u5047\u8bbe\u4f60\u6709\u4e00\u4e9b\u4efb\u52a1\uff0c\u6bcf\u4e2a\u4efb\u52a1\u5728\u4e00\u6bb5\u65f6\u95f4\u5185\u8fdb\u884c\uff0c\u4f60\u7684\u76ee\u6807\u662f\u5b8c\u6210\u5c3d\u53ef\u80fd\u591a\u7684\u4efb\u52a1\u3002\u5982\u679c\u6bcf\u6b21\u90fd\u9009\u62e9\u7ed3\u675f\u65f6\u95f4\u6700\u65e9\u7684\u4efb\u52a1\uff0c\u90a3\u4e48\u8d2a\u5fc3\u7b97\u6cd5\u5c31\u53ef\u4ee5\u5f97\u5230\u6700\u4f18\u89e3\u3002
    • \u5206\u6570\u80cc\u5305\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u7ec4\u7269\u54c1\u548c\u4e00\u4e2a\u8f7d\u91cd\u91cf\uff0c\u4f60\u7684\u76ee\u6807\u662f\u9009\u62e9\u4e00\u7ec4\u7269\u54c1\uff0c\u4f7f\u5f97\u603b\u91cd\u91cf\u4e0d\u8d85\u8fc7\u8f7d\u91cd\u91cf\uff0c\u4e14\u603b\u4ef7\u503c\u6700\u5927\u3002\u5982\u679c\u6bcf\u6b21\u90fd\u9009\u62e9\u6027\u4ef7\u6bd4\u6700\u9ad8\uff08\u4ef7\u503c / \u91cd\u91cf\uff09\u7684\u7269\u54c1\uff0c\u90a3\u4e48\u8d2a\u5fc3\u7b97\u6cd5\u5728\u4e00\u4e9b\u60c5\u51b5\u4e0b\u53ef\u4ee5\u5f97\u5230\u6700\u4f18\u89e3\u3002
    • \u80a1\u7968\u4e70\u5356\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u7ec4\u80a1\u7968\u7684\u5386\u53f2\u4ef7\u683c\uff0c\u4f60\u53ef\u4ee5\u8fdb\u884c\u591a\u6b21\u4e70\u5356\uff0c\u4f46\u5982\u679c\u4f60\u5df2\u7ecf\u6301\u6709\u80a1\u7968\uff0c\u90a3\u4e48\u5728\u5356\u51fa\u4e4b\u524d\u4e0d\u80fd\u518d\u4e70\uff0c\u76ee\u6807\u662f\u83b7\u53d6\u6700\u5927\u5229\u6da6\u3002
    • \u970d\u592b\u66fc\u7f16\u7801\uff1a\u970d\u592b\u66fc\u7f16\u7801\u662f\u4e00\u79cd\u7528\u4e8e\u65e0\u635f\u6570\u636e\u538b\u7f29\u7684\u8d2a\u5fc3\u7b97\u6cd5\u3002\u901a\u8fc7\u6784\u5efa\u970d\u592b\u66fc\u6811\uff0c\u6bcf\u6b21\u9009\u62e9\u51fa\u73b0\u9891\u7387\u6700\u4f4e\u7684\u4e24\u4e2a\u8282\u70b9\u5408\u5e76\uff0c\u6700\u540e\u5f97\u5230\u7684\u970d\u592b\u66fc\u6811\u7684\u5e26\u6743\u8def\u5f84\u957f\u5ea6\uff08\u7f16\u7801\u957f\u5ea6\uff09\u6700\u5c0f\u3002
    • Dijkstra \u7b97\u6cd5\uff1a\u5b83\u662f\u4e00\u79cd\u89e3\u51b3\u7ed9\u5b9a\u6e90\u9876\u70b9\u5230\u5176\u4f59\u5404\u9876\u70b9\u7684\u6700\u77ed\u8def\u5f84\u95ee\u9898\u7684\u8d2a\u5fc3\u7b97\u6cd5\u3002
    "},{"location":"chapter_greedy/max_capacity_problem/","title":"15.3 \u00a0 \u6700\u5927\u5bb9\u91cf\u95ee\u9898","text":"

    Question

    \u8f93\u5165\u4e00\u4e2a\u6570\u7ec4 \\(ht\\) \uff0c\u5176\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\u4ee3\u8868\u4e00\u4e2a\u5782\u76f4\u9694\u677f\u7684\u9ad8\u5ea6\u3002\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u4e24\u4e2a\u9694\u677f\uff0c\u4ee5\u53ca\u5b83\u4eec\u4e4b\u95f4\u7684\u7a7a\u95f4\u53ef\u4ee5\u7ec4\u6210\u4e00\u4e2a\u5bb9\u5668\u3002

    \u5bb9\u5668\u7684\u5bb9\u91cf\u7b49\u4e8e\u9ad8\u5ea6\u548c\u5bbd\u5ea6\u7684\u4e58\u79ef\uff08\u9762\u79ef\uff09\uff0c\u5176\u4e2d\u9ad8\u5ea6\u7531\u8f83\u77ed\u7684\u9694\u677f\u51b3\u5b9a\uff0c\u5bbd\u5ea6\u662f\u4e24\u4e2a\u9694\u677f\u7684\u6570\u7ec4\u7d22\u5f15\u4e4b\u5dee\u3002

    \u8bf7\u5728\u6570\u7ec4\u4e2d\u9009\u62e9\u4e24\u4e2a\u9694\u677f\uff0c\u4f7f\u5f97\u7ec4\u6210\u7684\u5bb9\u5668\u7684\u5bb9\u91cf\u6700\u5927\uff0c\u8fd4\u56de\u6700\u5927\u5bb9\u91cf\u3002\u793a\u4f8b\u5982\u56fe 15-7 \u6240\u793a\u3002

    \u56fe 15-7 \u00a0 \u6700\u5927\u5bb9\u91cf\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    \u5bb9\u5668\u7531\u4efb\u610f\u4e24\u4e2a\u9694\u677f\u56f4\u6210\uff0c\u56e0\u6b64\u672c\u9898\u7684\u72b6\u6001\u4e3a\u4e24\u4e2a\u9694\u677f\u7684\u7d22\u5f15\uff0c\u8bb0\u4e3a \\([i, j]\\) \u3002

    \u6839\u636e\u9898\u610f\uff0c\u5bb9\u91cf\u7b49\u4e8e\u9ad8\u5ea6\u4e58\u4ee5\u5bbd\u5ea6\uff0c\u5176\u4e2d\u9ad8\u5ea6\u7531\u77ed\u677f\u51b3\u5b9a\uff0c\u5bbd\u5ea6\u662f\u4e24\u9694\u677f\u7684\u6570\u7ec4\u7d22\u5f15\u4e4b\u5dee\u3002\u8bbe\u5bb9\u91cf\u4e3a \\(cap[i, j]\\) \uff0c\u5219\u53ef\u5f97\u8ba1\u7b97\u516c\u5f0f\uff1a

    \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\]

    \u8bbe\u6570\u7ec4\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u4e24\u4e2a\u9694\u677f\u7684\u7ec4\u5408\u6570\u91cf\uff08\u72b6\u6001\u603b\u6570\uff09\u4e3a \\(C_n^2 = \\frac{n(n - 1)}{2}\\) \u4e2a\u3002\u6700\u76f4\u63a5\u5730\uff0c\u6211\u4eec\u53ef\u4ee5\u7a77\u4e3e\u6240\u6709\u72b6\u6001\uff0c\u4ece\u800c\u6c42\u5f97\u6700\u5927\u5bb9\u91cf\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_greedy/max_capacity_problem/#1","title":"1. \u00a0 \u8d2a\u5fc3\u7b56\u7565\u786e\u5b9a","text":"

    \u8fd9\u9053\u9898\u8fd8\u6709\u66f4\u9ad8\u6548\u7387\u7684\u89e3\u6cd5\u3002\u5982\u56fe 15-8 \u6240\u793a\uff0c\u73b0\u9009\u53d6\u4e00\u4e2a\u72b6\u6001 \\([i, j]\\) \uff0c\u5176\u6ee1\u8db3\u7d22\u5f15 \\(i < j\\) \u4e14\u9ad8\u5ea6 \\(ht[i] < ht[j]\\) \uff0c\u5373 \\(i\\) \u4e3a\u77ed\u677f\u3001\\(j\\) \u4e3a\u957f\u677f\u3002

    \u56fe 15-8 \u00a0 \u521d\u59cb\u72b6\u6001

    \u5982\u56fe 15-9 \u6240\u793a\uff0c\u82e5\u6b64\u65f6\u5c06\u957f\u677f \\(j\\) \u5411\u77ed\u677f \\(i\\) \u9760\u8fd1\uff0c\u5219\u5bb9\u91cf\u4e00\u5b9a\u53d8\u5c0f\u3002

    \u8fd9\u662f\u56e0\u4e3a\u5728\u79fb\u52a8\u957f\u677f \\(j\\) \u540e\uff0c\u5bbd\u5ea6 \\(j-i\\) \u80af\u5b9a\u53d8\u5c0f\uff1b\u800c\u9ad8\u5ea6\u7531\u77ed\u677f\u51b3\u5b9a\uff0c\u56e0\u6b64\u9ad8\u5ea6\u53ea\u53ef\u80fd\u4e0d\u53d8\uff08 \\(i\\) \u4ecd\u4e3a\u77ed\u677f\uff09\u6216\u53d8\u5c0f\uff08\u79fb\u52a8\u540e\u7684 \\(j\\) \u6210\u4e3a\u77ed\u677f\uff09\u3002

    \u56fe 15-9 \u00a0 \u5411\u5185\u79fb\u52a8\u957f\u677f\u540e\u7684\u72b6\u6001

    \u53cd\u5411\u601d\u8003\uff0c\u6211\u4eec\u53ea\u6709\u5411\u5185\u6536\u7f29\u77ed\u677f \\(i\\) \uff0c\u624d\u6709\u53ef\u80fd\u4f7f\u5bb9\u91cf\u53d8\u5927\u3002\u56e0\u4e3a\u867d\u7136\u5bbd\u5ea6\u4e00\u5b9a\u53d8\u5c0f\uff0c\u4f46\u9ad8\u5ea6\u53ef\u80fd\u4f1a\u53d8\u5927\uff08\u79fb\u52a8\u540e\u7684\u77ed\u677f \\(i\\) \u53ef\u80fd\u4f1a\u53d8\u957f\uff09\u3002\u4f8b\u5982\u5728\u56fe 15-10 \u4e2d\uff0c\u79fb\u52a8\u77ed\u677f\u540e\u9762\u79ef\u53d8\u5927\u3002

    \u56fe 15-10 \u00a0 \u5411\u5185\u79fb\u52a8\u77ed\u677f\u540e\u7684\u72b6\u6001

    \u7531\u6b64\u4fbf\u53ef\u63a8\u51fa\u672c\u9898\u7684\u8d2a\u5fc3\u7b56\u7565\uff1a\u521d\u59cb\u5316\u4e24\u6307\u9488\uff0c\u4f7f\u5176\u5206\u5217\u5bb9\u5668\u4e24\u7aef\uff0c\u6bcf\u8f6e\u5411\u5185\u6536\u7f29\u77ed\u677f\u5bf9\u5e94\u7684\u6307\u9488\uff0c\u76f4\u81f3\u4e24\u6307\u9488\u76f8\u9047\u3002

    \u56fe 15-11 \u5c55\u793a\u4e86\u8d2a\u5fc3\u7b56\u7565\u7684\u6267\u884c\u8fc7\u7a0b\u3002

    1. \u521d\u59cb\u72b6\u6001\u4e0b\uff0c\u6307\u9488 \\(i\\) \u548c \\(j\\) \u5206\u5217\u6570\u7ec4\u4e24\u7aef\u3002
    2. \u8ba1\u7b97\u5f53\u524d\u72b6\u6001\u7684\u5bb9\u91cf \\(cap[i, j]\\) \uff0c\u5e76\u66f4\u65b0\u6700\u5927\u5bb9\u91cf\u3002
    3. \u6bd4\u8f83\u677f \\(i\\) \u548c \u677f \\(j\\) \u7684\u9ad8\u5ea6\uff0c\u5e76\u5c06\u77ed\u677f\u5411\u5185\u79fb\u52a8\u4e00\u683c\u3002
    4. \u5faa\u73af\u6267\u884c\u7b2c 2. \u6b65\u548c\u7b2c 3. \u6b65\uff0c\u76f4\u81f3 \\(i\\) \u548c \\(j\\) \u76f8\u9047\u65f6\u7ed3\u675f\u3002
    <1><2><3><4><5><6><7><8><9>

    \u56fe 15-11 \u00a0 \u6700\u5927\u5bb9\u91cf\u95ee\u9898\u7684\u8d2a\u5fc3\u8fc7\u7a0b

    "},{"location":"chapter_greedy/max_capacity_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u4ee3\u7801\u5faa\u73af\u6700\u591a \\(n\\) \u8f6e\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    \u53d8\u91cf \\(i\\)\u3001\\(j\\)\u3001\\(res\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig max_capacity.py
    def max_capacity(ht: list[int]) -> int:\n    \"\"\"\u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3\"\"\"\n    # \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    i, j = 0, len(ht) - 1\n    # \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    res = 0\n    # \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while i < j:\n        # \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if ht[i] < ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n
    max_capacity.cpp
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint maxCapacity(vector<int> &ht) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    int i = 0, j = ht.size() - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    int res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n
    max_capacity.java
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint maxCapacity(int[] ht) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    int i = 0, j = ht.length - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    int res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n
    max_capacity.cs
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint MaxCapacity(int[] ht) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    int i = 0, j = ht.Length - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    int res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n
    max_capacity.go
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfunc maxCapacity(ht []int) int {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    i, j := 0, len(ht)-1\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    res := 0\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    for i < j {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if ht[i] < ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n
    max_capacity.swift
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfunc maxCapacity(ht: [Int]) -> Int {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    var res = 0\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while i < j {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if ht[i] < ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n
    max_capacity.js
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfunction maxCapacity(ht) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    let i = 0,\n        j = ht.length - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    let res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n
    max_capacity.ts
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfunction maxCapacity(ht: number[]): number {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    let i = 0,\n        j = ht.length - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    let res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n
    max_capacity.dart
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint maxCapacity(List<int> ht) {\n  // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n  int i = 0, j = ht.length - 1;\n  // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n  int res = 0;\n  // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n  while (i < j) {\n    // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n    if (ht[i] < ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n
    max_capacity.rs
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfn max_capacity(ht: &[i32]) -> i32 {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    let mut res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while i < j {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if ht[i] < ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n
    max_capacity.c
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint maxCapacity(int ht[], int htLength) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    int i = 0;\n    int j = htLength - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    int res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n
    max_capacity.kt
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfun maxCapacity(ht: IntArray): Int {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    var i = 0\n    var j = ht.size - 1\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    var res = 0\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        val cap = (min(ht[i].toDouble(), ht[j].toDouble()) * (j - i)).toInt()\n        res = max(res.toDouble(), cap.toDouble()).toInt()\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n
    max_capacity.rb
    [class]{}-[func]{max_capacity}\n
    max_capacity.zig
    [class]{}-[func]{maxCapacity}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_greedy/max_capacity_problem/#3","title":"3. \u00a0 \u6b63\u786e\u6027\u8bc1\u660e","text":"

    \u4e4b\u6240\u4ee5\u8d2a\u5fc3\u6bd4\u7a77\u4e3e\u66f4\u5feb\uff0c\u662f\u56e0\u4e3a\u6bcf\u8f6e\u7684\u8d2a\u5fc3\u9009\u62e9\u90fd\u4f1a\u201c\u8df3\u8fc7\u201d\u4e00\u4e9b\u72b6\u6001\u3002

    \u6bd4\u5982\u5728\u72b6\u6001 \\(cap[i, j]\\) \u4e0b\uff0c\\(i\\) \u4e3a\u77ed\u677f\u3001\\(j\\) \u4e3a\u957f\u677f\u3002\u82e5\u8d2a\u5fc3\u5730\u5c06\u77ed\u677f \\(i\\) \u5411\u5185\u79fb\u52a8\u4e00\u683c\uff0c\u4f1a\u5bfc\u81f4\u56fe 15-12 \u6240\u793a\u7684\u72b6\u6001\u88ab\u201c\u8df3\u8fc7\u201d\u3002\u8fd9\u610f\u5473\u7740\u4e4b\u540e\u65e0\u6cd5\u9a8c\u8bc1\u8fd9\u4e9b\u72b6\u6001\u7684\u5bb9\u91cf\u5927\u5c0f\u3002

    \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\]

    \u56fe 15-12 \u00a0 \u79fb\u52a8\u77ed\u677f\u5bfc\u81f4\u88ab\u8df3\u8fc7\u7684\u72b6\u6001

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u8fd9\u4e9b\u88ab\u8df3\u8fc7\u7684\u72b6\u6001\u5b9e\u9645\u4e0a\u5c31\u662f\u5c06\u957f\u677f \\(j\\) \u5411\u5185\u79fb\u52a8\u7684\u6240\u6709\u72b6\u6001\u3002\u524d\u9762\u6211\u4eec\u5df2\u7ecf\u8bc1\u660e\u5185\u79fb\u957f\u677f\u4e00\u5b9a\u4f1a\u5bfc\u81f4\u5bb9\u91cf\u53d8\u5c0f\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u88ab\u8df3\u8fc7\u7684\u72b6\u6001\u90fd\u4e0d\u53ef\u80fd\u662f\u6700\u4f18\u89e3\uff0c\u8df3\u8fc7\u5b83\u4eec\u4e0d\u4f1a\u5bfc\u81f4\u9519\u8fc7\u6700\u4f18\u89e3\u3002

    \u4ee5\u4e0a\u5206\u6790\u8bf4\u660e\uff0c\u79fb\u52a8\u77ed\u677f\u7684\u64cd\u4f5c\u662f\u201c\u5b89\u5168\u201d\u7684\uff0c\u8d2a\u5fc3\u7b56\u7565\u662f\u6709\u6548\u7684\u3002

    "},{"location":"chapter_greedy/max_product_cutting_problem/","title":"15.4 \u00a0 \u6700\u5927\u5207\u5206\u4e58\u79ef\u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6b63\u6574\u6570 \\(n\\) \uff0c\u5c06\u5176\u5207\u5206\u4e3a\u81f3\u5c11\u4e24\u4e2a\u6b63\u6574\u6570\u7684\u548c\uff0c\u6c42\u5207\u5206\u540e\u6240\u6709\u6574\u6570\u7684\u4e58\u79ef\u6700\u5927\u662f\u591a\u5c11\uff0c\u5982\u56fe 15-13 \u6240\u793a\u3002

    \u56fe 15-13 \u00a0 \u6700\u5927\u5207\u5206\u4e58\u79ef\u7684\u95ee\u9898\u5b9a\u4e49

    \u5047\u8bbe\u6211\u4eec\u5c06 \\(n\\) \u5207\u5206\u4e3a \\(m\\) \u4e2a\u6574\u6570\u56e0\u5b50\uff0c\u5176\u4e2d\u7b2c \\(i\\) \u4e2a\u56e0\u5b50\u8bb0\u4e3a \\(n_i\\) \uff0c\u5373

    \\[ n = \\sum_{i=1}^{m}n_i \\]

    \u672c\u9898\u7684\u76ee\u6807\u662f\u6c42\u5f97\u6240\u6709\u6574\u6570\u56e0\u5b50\u7684\u6700\u5927\u4e58\u79ef\uff0c\u5373

    \\[ \\max(\\prod_{i=1}^{m}n_i) \\]

    \u6211\u4eec\u9700\u8981\u601d\u8003\u7684\u662f\uff1a\u5207\u5206\u6570\u91cf \\(m\\) \u5e94\u8be5\u591a\u5927\uff0c\u6bcf\u4e2a \\(n_i\\) \u5e94\u8be5\u662f\u591a\u5c11\uff1f

    "},{"location":"chapter_greedy/max_product_cutting_problem/#1","title":"1. \u00a0 \u8d2a\u5fc3\u7b56\u7565\u786e\u5b9a","text":"

    \u6839\u636e\u7ecf\u9a8c\uff0c\u4e24\u4e2a\u6574\u6570\u7684\u4e58\u79ef\u5f80\u5f80\u6bd4\u5b83\u4eec\u7684\u52a0\u548c\u66f4\u5927\u3002\u5047\u8bbe\u4ece \\(n\\) \u4e2d\u5206\u51fa\u4e00\u4e2a\u56e0\u5b50 \\(2\\) \uff0c\u5219\u5b83\u4eec\u7684\u4e58\u79ef\u4e3a \\(2(n-2)\\) \u3002\u6211\u4eec\u5c06\u8be5\u4e58\u79ef\u4e0e \\(n\\) \u4f5c\u6bd4\u8f83\uff1a

    \\[ \\begin{aligned} 2(n-2) & \\geq n \\newline 2n - n - 4 & \\geq 0 \\newline n & \\geq 4 \\end{aligned} \\]

    \u5982\u56fe 15-14 \u6240\u793a\uff0c\u5f53 \\(n \\geq 4\\) \u65f6\uff0c\u5207\u5206\u51fa\u4e00\u4e2a \\(2\\) \u540e\u4e58\u79ef\u4f1a\u53d8\u5927\uff0c\u8fd9\u8bf4\u660e\u5927\u4e8e\u7b49\u4e8e \\(4\\) \u7684\u6574\u6570\u90fd\u5e94\u8be5\u88ab\u5207\u5206\u3002

    \u8d2a\u5fc3\u7b56\u7565\u4e00\uff1a\u5982\u679c\u5207\u5206\u65b9\u6848\u4e2d\u5305\u542b \\(\\geq 4\\) \u7684\u56e0\u5b50\uff0c\u90a3\u4e48\u5b83\u5c31\u5e94\u8be5\u88ab\u7ee7\u7eed\u5207\u5206\u3002\u6700\u7ec8\u7684\u5207\u5206\u65b9\u6848\u53ea\u5e94\u51fa\u73b0 \\(1\\)\u3001\\(2\\)\u3001\\(3\\) \u8fd9\u4e09\u79cd\u56e0\u5b50\u3002

    \u56fe 15-14 \u00a0 \u5207\u5206\u5bfc\u81f4\u4e58\u79ef\u53d8\u5927

    \u63a5\u4e0b\u6765\u601d\u8003\u54ea\u4e2a\u56e0\u5b50\u662f\u6700\u4f18\u7684\u3002\u5728 \\(1\\)\u3001\\(2\\)\u3001\\(3\\) \u8fd9\u4e09\u4e2a\u56e0\u5b50\u4e2d\uff0c\u663e\u7136 \\(1\\) \u662f\u6700\u5dee\u7684\uff0c\u56e0\u4e3a \\(1 \\times (n-1) < n\\) \u6052\u6210\u7acb\uff0c\u5373\u5207\u5206\u51fa \\(1\\) \u53cd\u800c\u4f1a\u5bfc\u81f4\u4e58\u79ef\u51cf\u5c0f\u3002

    \u5982\u56fe 15-15 \u6240\u793a\uff0c\u5f53 \\(n = 6\\) \u65f6\uff0c\u6709 \\(3 \\times 3 > 2 \\times 2 \\times 2\\) \u3002\u8fd9\u610f\u5473\u7740\u5207\u5206\u51fa \\(3\\) \u6bd4\u5207\u5206\u51fa \\(2\\) \u66f4\u4f18\u3002

    \u8d2a\u5fc3\u7b56\u7565\u4e8c\uff1a\u5728\u5207\u5206\u65b9\u6848\u4e2d\uff0c\u6700\u591a\u53ea\u5e94\u5b58\u5728\u4e24\u4e2a \\(2\\) \u3002\u56e0\u4e3a\u4e09\u4e2a \\(2\\) \u603b\u662f\u53ef\u4ee5\u66ff\u6362\u4e3a\u4e24\u4e2a \\(3\\) \uff0c\u4ece\u800c\u83b7\u5f97\u66f4\u5927\u7684\u4e58\u79ef\u3002

    \u56fe 15-15 \u00a0 \u6700\u4f18\u5207\u5206\u56e0\u5b50

    \u7efc\u4e0a\u6240\u8ff0\uff0c\u53ef\u63a8\u7406\u51fa\u4ee5\u4e0b\u8d2a\u5fc3\u7b56\u7565\u3002

    1. \u8f93\u5165\u6574\u6570 \\(n\\) \uff0c\u4ece\u5176\u4e0d\u65ad\u5730\u5207\u5206\u51fa\u56e0\u5b50 \\(3\\) \uff0c\u76f4\u81f3\u4f59\u6570\u4e3a \\(0\\)\u3001\\(1\\)\u3001\\(2\\) \u3002
    2. \u5f53\u4f59\u6570\u4e3a \\(0\\) \u65f6\uff0c\u4ee3\u8868 \\(n\\) \u662f \\(3\\) \u7684\u500d\u6570\uff0c\u56e0\u6b64\u4e0d\u505a\u4efb\u4f55\u5904\u7406\u3002
    3. \u5f53\u4f59\u6570\u4e3a \\(2\\) \u65f6\uff0c\u4e0d\u7ee7\u7eed\u5212\u5206\uff0c\u4fdd\u7559\u3002
    4. \u5f53\u4f59\u6570\u4e3a \\(1\\) \u65f6\uff0c\u7531\u4e8e \\(2 \\times 2 > 1 \\times 3\\) \uff0c\u56e0\u6b64\u5e94\u5c06\u6700\u540e\u4e00\u4e2a \\(3\\) \u66ff\u6362\u4e3a \\(2\\) \u3002
    "},{"location":"chapter_greedy/max_product_cutting_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5982\u56fe 15-16 \u6240\u793a\uff0c\u6211\u4eec\u65e0\u987b\u901a\u8fc7\u5faa\u73af\u6765\u5207\u5206\u6574\u6570\uff0c\u800c\u53ef\u4ee5\u5229\u7528\u5411\u4e0b\u6574\u9664\u8fd0\u7b97\u5f97\u5230 \\(3\\) \u7684\u4e2a\u6570 \\(a\\) \uff0c\u7528\u53d6\u6a21\u8fd0\u7b97\u5f97\u5230\u4f59\u6570 \\(b\\) \uff0c\u6b64\u65f6\u6709\uff1a

    \\[ n = 3 a + b \\]

    \u8bf7\u6ce8\u610f\uff0c\u5bf9\u4e8e \\(n \\leq 3\\) \u7684\u8fb9\u754c\u60c5\u51b5\uff0c\u5fc5\u987b\u62c6\u5206\u51fa\u4e00\u4e2a \\(1\\) \uff0c\u4e58\u79ef\u4e3a \\(1 \\times (n - 1)\\) \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig max_product_cutting.py
    def max_product_cutting(n: int) -> int:\n    \"\"\"\u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3\"\"\"\n    # \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if n <= 3:\n        return 1 * (n - 1)\n    # \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    a, b = n // 3, n % 3\n    if b == 1:\n        # \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return int(math.pow(3, a)) * 2\n    # \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return int(math.pow(3, a))\n
    max_product_cutting.cpp
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint maxProductCutting(int n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return (int)pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return (int)pow(3, a);\n}\n
    max_product_cutting.java
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint maxProductCutting(int n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return (int) Math.pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return (int) Math.pow(3, a);\n}\n
    max_product_cutting.cs
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint MaxProductCutting(int n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return (int)Math.Pow(3, a);\n}\n
    max_product_cutting.go
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfunc maxProductCutting(n int) int {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if n <= 3 {\n        return 1 * (n - 1)\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return int(math.Pow(3, float64(a)))\n}\n
    max_product_cutting.swift
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfunc maxProductCutting(n: Int) -> Int {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if n <= 3 {\n        return 1 * (n - 1)\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return pow(3, a) * 2\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return pow(3, a)\n}\n
    max_product_cutting.js
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfunction maxProductCutting(n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return Math.pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return Math.pow(3, a);\n}\n
    max_product_cutting.ts
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfunction maxProductCutting(n: number): number {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return Math.pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return Math.pow(3, a);\n}\n
    max_product_cutting.dart
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint maxProductCutting(int n) {\n  // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n  if (n <= 3) {\n    return 1 * (n - 1);\n  }\n  // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return (pow(3, a) * 2).toInt();\n  }\n  // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n  return pow(3, a).toInt();\n}\n
    max_product_cutting.rs
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfn max_product_cutting(n: i32) -> i32 {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if n <= 3 {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        3_i32.pow(a as u32) * 2\n    } else {\n        // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        3_i32.pow(a as u32)\n    }\n}\n
    max_product_cutting.c
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint maxProductCutting(int n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return pow(3, a);\n}\n
    max_product_cutting.kt
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfun maxProductCutting(n: Int): Int {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1)\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return 3.0.pow((a - 1).toDouble()).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return 3.0.pow(a.toDouble()).toInt() * 2 * 2\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return 3.0.pow(a.toDouble()).toInt()\n}\n
    max_product_cutting.rb
    [class]{}-[func]{max_product_cutting}\n
    max_product_cutting.zig
    [class]{}-[func]{maxProductCutting}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 15-16 \u00a0 \u6700\u5927\u5207\u5206\u4e58\u79ef\u7684\u8ba1\u7b97\u65b9\u6cd5

    \u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u7f16\u7a0b\u8bed\u8a00\u7684\u5e42\u8fd0\u7b97\u7684\u5b9e\u73b0\u65b9\u6cd5\u3002\u4ee5 Python \u4e3a\u4f8b\uff0c\u5e38\u7528\u7684\u5e42\u8ba1\u7b97\u51fd\u6570\u6709\u4e09\u79cd\u3002

    • \u8fd0\u7b97\u7b26 ** \u548c\u51fd\u6570 pow() \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(\\log\u2061 a)\\) \u3002
    • \u51fd\u6570 math.pow() \u5185\u90e8\u8c03\u7528 C \u8bed\u8a00\u5e93\u7684 pow() \u51fd\u6570\uff0c\u5176\u6267\u884c\u6d6e\u70b9\u53d6\u5e42\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002

    \u53d8\u91cf \\(a\\) \u548c \\(b\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002

    "},{"location":"chapter_greedy/max_product_cutting_problem/#3","title":"3. \u00a0 \u6b63\u786e\u6027\u8bc1\u660e","text":"

    \u4f7f\u7528\u53cd\u8bc1\u6cd5\uff0c\u53ea\u5206\u6790 \\(n \\geq 3\\) \u7684\u60c5\u51b5\u3002

    1. \u6240\u6709\u56e0\u5b50 \\(\\leq 3\\) \uff1a\u5047\u8bbe\u6700\u4f18\u5207\u5206\u65b9\u6848\u4e2d\u5b58\u5728 \\(\\geq 4\\) \u7684\u56e0\u5b50 \\(x\\) \uff0c\u90a3\u4e48\u4e00\u5b9a\u53ef\u4ee5\u5c06\u5176\u7ee7\u7eed\u5212\u5206\u4e3a \\(2(x-2)\\) \uff0c\u4ece\u800c\u83b7\u5f97\u66f4\u5927\u7684\u4e58\u79ef\u3002\u8fd9\u4e0e\u5047\u8bbe\u77db\u76fe\u3002
    2. \u5207\u5206\u65b9\u6848\u4e0d\u5305\u542b \\(1\\) \uff1a\u5047\u8bbe\u6700\u4f18\u5207\u5206\u65b9\u6848\u4e2d\u5b58\u5728\u4e00\u4e2a\u56e0\u5b50 \\(1\\) \uff0c\u90a3\u4e48\u5b83\u4e00\u5b9a\u53ef\u4ee5\u5408\u5e76\u5165\u53e6\u5916\u4e00\u4e2a\u56e0\u5b50\u4e2d\uff0c\u4ee5\u83b7\u5f97\u66f4\u5927\u7684\u4e58\u79ef\u3002\u8fd9\u4e0e\u5047\u8bbe\u77db\u76fe\u3002
    3. \u5207\u5206\u65b9\u6848\u6700\u591a\u5305\u542b\u4e24\u4e2a \\(2\\) \uff1a\u5047\u8bbe\u6700\u4f18\u5207\u5206\u65b9\u6848\u4e2d\u5305\u542b\u4e09\u4e2a \\(2\\) \uff0c\u90a3\u4e48\u4e00\u5b9a\u53ef\u4ee5\u66ff\u6362\u4e3a\u4e24\u4e2a \\(3\\) \uff0c\u4e58\u79ef\u66f4\u5927\u3002\u8fd9\u4e0e\u5047\u8bbe\u77db\u76fe\u3002
    "},{"location":"chapter_greedy/summary/","title":"15.5 \u00a0 \u5c0f\u7ed3","text":"
    • \u8d2a\u5fc3\u7b97\u6cd5\u901a\u5e38\u7528\u4e8e\u89e3\u51b3\u6700\u4f18\u5316\u95ee\u9898\uff0c\u5176\u539f\u7406\u662f\u5728\u6bcf\u4e2a\u51b3\u7b56\u9636\u6bb5\u90fd\u505a\u51fa\u5c40\u90e8\u6700\u4f18\u7684\u51b3\u7b56\uff0c\u4ee5\u671f\u83b7\u5f97\u5168\u5c40\u6700\u4f18\u89e3\u3002
    • \u8d2a\u5fc3\u7b97\u6cd5\u4f1a\u8fed\u4ee3\u5730\u505a\u51fa\u4e00\u4e2a\u53c8\u4e00\u4e2a\u7684\u8d2a\u5fc3\u9009\u62e9\uff0c\u6bcf\u8f6e\u90fd\u5c06\u95ee\u9898\u8f6c\u5316\u6210\u4e00\u4e2a\u89c4\u6a21\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\uff0c\u76f4\u5230\u95ee\u9898\u88ab\u89e3\u51b3\u3002
    • \u8d2a\u5fc3\u7b97\u6cd5\u4e0d\u4ec5\u5b9e\u73b0\u7b80\u5355\uff0c\u8fd8\u5177\u6709\u5f88\u9ad8\u7684\u89e3\u9898\u6548\u7387\u3002\u76f8\u6bd4\u4e8e\u52a8\u6001\u89c4\u5212\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u66f4\u4f4e\u3002
    • \u5728\u96f6\u94b1\u5151\u6362\u95ee\u9898\u4e2d\uff0c\u5bf9\u4e8e\u67d0\u4e9b\u786c\u5e01\u7ec4\u5408\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u53ef\u4ee5\u4fdd\u8bc1\u627e\u5230\u6700\u4f18\u89e3\uff1b\u5bf9\u4e8e\u53e6\u5916\u4e00\u4e9b\u786c\u5e01\u7ec4\u5408\u5219\u4e0d\u7136\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u53ef\u80fd\u627e\u5230\u5f88\u5dee\u7684\u89e3\u3002
    • \u9002\u5408\u7528\u8d2a\u5fc3\u7b97\u6cd5\u6c42\u89e3\u7684\u95ee\u9898\u5177\u6709\u4e24\u5927\u6027\u8d28\uff1a\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u548c\u6700\u4f18\u5b50\u7ed3\u6784\u3002\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u4ee3\u8868\u8d2a\u5fc3\u7b56\u7565\u7684\u6709\u6548\u6027\u3002
    • \u5bf9\u4e8e\u67d0\u4e9b\u590d\u6742\u95ee\u9898\uff0c\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u7684\u8bc1\u660e\u5e76\u4e0d\u7b80\u5355\u3002\u76f8\u5bf9\u6765\u8bf4\uff0c\u8bc1\u4f2a\u66f4\u52a0\u5bb9\u6613\uff0c\u4f8b\u5982\u96f6\u94b1\u5151\u6362\u95ee\u9898\u3002
    • \u6c42\u89e3\u8d2a\u5fc3\u95ee\u9898\u4e3b\u8981\u5206\u4e3a\u4e09\u6b65\uff1a\u95ee\u9898\u5206\u6790\u3001\u786e\u5b9a\u8d2a\u5fc3\u7b56\u7565\u3001\u6b63\u786e\u6027\u8bc1\u660e\u3002\u5176\u4e2d\uff0c\u786e\u5b9a\u8d2a\u5fc3\u7b56\u7565\u662f\u6838\u5fc3\u6b65\u9aa4\uff0c\u6b63\u786e\u6027\u8bc1\u660e\u5f80\u5f80\u662f\u96be\u70b9\u3002
    • \u5206\u6570\u80cc\u5305\u95ee\u9898\u5728 0-1 \u80cc\u5305\u7684\u57fa\u7840\u4e0a\uff0c\u5141\u8bb8\u9009\u62e9\u7269\u54c1\u7684\u4e00\u90e8\u5206\uff0c\u56e0\u6b64\u53ef\u4f7f\u7528\u8d2a\u5fc3\u7b97\u6cd5\u6c42\u89e3\u3002\u8d2a\u5fc3\u7b56\u7565\u7684\u6b63\u786e\u6027\u53ef\u4ee5\u4f7f\u7528\u53cd\u8bc1\u6cd5\u6765\u8bc1\u660e\u3002
    • \u6700\u5927\u5bb9\u91cf\u95ee\u9898\u53ef\u4f7f\u7528\u7a77\u4e3e\u6cd5\u6c42\u89e3\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002\u901a\u8fc7\u8bbe\u8ba1\u8d2a\u5fc3\u7b56\u7565\uff0c\u6bcf\u8f6e\u5411\u5185\u79fb\u52a8\u77ed\u677f\uff0c\u53ef\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(n)\\) \u3002
    • \u5728\u6700\u5927\u5207\u5206\u4e58\u79ef\u95ee\u9898\u4e2d\uff0c\u6211\u4eec\u5148\u540e\u63a8\u7406\u51fa\u4e24\u4e2a\u8d2a\u5fc3\u7b56\u7565\uff1a\\(\\geq 4\\) \u7684\u6574\u6570\u90fd\u5e94\u8be5\u7ee7\u7eed\u5207\u5206\uff0c\u6700\u4f18\u5207\u5206\u56e0\u5b50\u4e3a \\(3\\) \u3002\u4ee3\u7801\u4e2d\u5305\u542b\u5e42\u8fd0\u7b97\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u5e42\u8fd0\u7b97\u5b9e\u73b0\u65b9\u6cd5\uff0c\u901a\u5e38\u4e3a \\(O(1)\\) \u6216 \\(O(\\log n)\\) \u3002
    "},{"location":"chapter_hashing/","title":"\u7b2c 6 \u7ae0 \u00a0 \u54c8\u5e0c\u8868","text":"

    Abstract

    \u5728\u8ba1\u7b97\u673a\u4e16\u754c\u4e2d\uff0c\u54c8\u5e0c\u8868\u5982\u540c\u4e00\u4f4d\u806a\u6167\u7684\u56fe\u4e66\u7ba1\u7406\u5458\u3002

    \u4ed6\u77e5\u9053\u5982\u4f55\u8ba1\u7b97\u7d22\u4e66\u53f7\uff0c\u4ece\u800c\u53ef\u4ee5\u5feb\u901f\u627e\u5230\u76ee\u6807\u56fe\u4e66\u3002

    "},{"location":"chapter_hashing/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 6.1 \u00a0 \u54c8\u5e0c\u8868
    • 6.2 \u00a0 \u54c8\u5e0c\u51b2\u7a81
    • 6.3 \u00a0 \u54c8\u5e0c\u7b97\u6cd5
    • 6.4 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_hashing/hash_algorithm/","title":"6.3 \u00a0 \u54c8\u5e0c\u7b97\u6cd5","text":"

    \u524d\u4e24\u8282\u4ecb\u7ecd\u4e86\u54c8\u5e0c\u8868\u7684\u5de5\u4f5c\u539f\u7406\u548c\u54c8\u5e0c\u51b2\u7a81\u7684\u5904\u7406\u65b9\u6cd5\u3002\u7136\u800c\u65e0\u8bba\u662f\u5f00\u653e\u5bfb\u5740\u8fd8\u662f\u94fe\u5f0f\u5730\u5740\uff0c\u5b83\u4eec\u53ea\u80fd\u4fdd\u8bc1\u54c8\u5e0c\u8868\u53ef\u4ee5\u5728\u53d1\u751f\u51b2\u7a81\u65f6\u6b63\u5e38\u5de5\u4f5c\uff0c\u800c\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\u5982\u56fe 6-8 \u6240\u793a\uff0c\u5bf9\u4e8e\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\uff0c\u7406\u60f3\u60c5\u51b5\u4e0b\u952e\u503c\u5bf9\u5747\u5300\u5206\u5e03\u5728\u5404\u4e2a\u6876\u4e2d\uff0c\u8fbe\u5230\u6700\u4f73\u67e5\u8be2\u6548\u7387\uff1b\u6700\u5dee\u60c5\u51b5\u4e0b\u6240\u6709\u952e\u503c\u5bf9\u90fd\u5b58\u50a8\u5230\u540c\u4e00\u4e2a\u6876\u4e2d\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u9000\u5316\u81f3 \\(O(n)\\) \u3002

    \u56fe 6-8 \u00a0 \u54c8\u5e0c\u51b2\u7a81\u7684\u6700\u4f73\u60c5\u51b5\u4e0e\u6700\u5dee\u60c5\u51b5

    \u952e\u503c\u5bf9\u7684\u5206\u5e03\u60c5\u51b5\u7531\u54c8\u5e0c\u51fd\u6570\u51b3\u5b9a\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\u60c5\u51b5\u3002

    \u8fd9\u610f\u5473\u7740\uff0c\u4e3a\u4e86\u964d\u4f4e\u54c8\u5e0c\u51b2\u7a81\u7684\u53d1\u751f\u6982\u7387\uff0c\u6211\u4eec\u5e94\u5f53\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\u5b9e\u73b0\u201c\u65e2\u5feb\u53c8\u7a33\u201d\u7684\u54c8\u5e0c\u8868\u6570\u636e\u7ed3\u6784\uff0c\u54c8\u5e0c\u7b97\u6cd5\u5e94\u5177\u5907\u4ee5\u4e0b\u7279\u70b9\u3002

    • \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\u5747\u5300\u5206\u5e03\u5728\u54c8\u5e0c\u8868\u4e2d\u3002\u5206\u5e03\u8d8a\u5747\u5300\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\u3002

    • \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\u3002

    \u5bf9\u4e8e\u5bc6\u7801\u5b66\u7684\u76f8\u5173\u5e94\u7528\uff0c\u4e3a\u4e86\u9632\u6b62\u4ece\u54c8\u5e0c\u503c\u63a8\u5bfc\u51fa\u539f\u59cb\u5bc6\u7801\u7b49\u9006\u5411\u5de5\u7a0b\uff0c\u54c8\u5e0c\u7b97\u6cd5\u9700\u8981\u5177\u5907\u66f4\u9ad8\u7b49\u7ea7\u7684\u5b89\u5168\u7279\u6027\u3002

    • \u5355\u5411\u6027\uff1a\u65e0\u6cd5\u901a\u8fc7\u54c8\u5e0c\u503c\u53cd\u63a8\u51fa\u5173\u4e8e\u8f93\u5165\u6570\u636e\u7684\u4efb\u4f55\u4fe1\u606f\u3002
    • \u6297\u78b0\u649e\u6027\uff1a\u5e94\u5f53\u6781\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

    \u8bf7\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\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\u9700\u8981\u8003\u8651\u8bb8\u591a\u56e0\u7d20\u7684\u590d\u6742\u95ee\u9898\u3002\u7136\u800c\u5bf9\u4e8e\u67d0\u4e9b\u8981\u6c42\u4e0d\u9ad8\u7684\u573a\u666f\uff0c\u6211\u4eec\u4e5f\u80fd\u8bbe\u8ba1\u4e00\u4e9b\u7b80\u5355\u7684\u54c8\u5e0c\u7b97\u6cd5\u3002

    • \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\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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig simple_hash.py
    def add_hash(key: str) -> int:\n    \"\"\"\u52a0\u6cd5\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -> int:\n    \"\"\"\u4e58\u6cd5\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -> int:\n    \"\"\"\u5f02\u6216\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -> int:\n    \"\"\"\u65cb\u8f6c\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash << 4) ^ (hash >> 28) ^ ord(c)\n    return hash % modulus\n
    simple_hash.cpp
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n
    simple_hash.java
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n
    simple_hash.cs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n
    simple_hash.go
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash & modulus\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n
    simple_hash.swift
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash & MODULUS\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash << 4) ^ (hash >> 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n
    simple_hash.js
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n
    simple_hash.ts
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n
    simple_hash.dart
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n
    simple_hash.rs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfn add_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfn mul_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfn xor_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash & MODULUS) as i32\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfn rot_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n
    simple_hash.c
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i < strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n
    simple_hash.kt
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfun addHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfun xorHash(key: String): Int {\n    var hash = 0\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n
    simple_hash.rb
    [class]{}-[func]{add_hash}\n\n[class]{}-[func]{mul_hash}\n\n[class]{}-[func]{xor_hash}\n\n[class]{}-[func]{rot_hash}\n
    simple_hash.zig
    [class]{}-[func]{addHash}\n\n[class]{}-[func]{mulHash}\n\n[class]{}-[func]{xorHash}\n\n[class]{}-[func]{rotHash}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\u6216\u8005\u8bf4\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\u4f7f\u7528\u5927\u8d28\u6570\u4f5c\u4e3a\u6a21\u6570\uff0c\u53ef\u4ee5\u6700\u5927\u5316\u5730\u4fdd\u8bc1\u54c8\u5e0c\u503c\u7684\u5747\u5300\u5206\u5e03\u3002\u56e0\u4e3a\u8d28\u6570\u4e0d\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\uff0c\u90a3\u4e48\u6240\u6709\u53ef\u4ee5\u88ab \\(3\\) \u6574\u9664\u7684 key \u90fd\u4f1a\u88ab\u6620\u5c04\u5230 \\(0\\)\u3001\\(3\\)\u3001\\(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, \\dots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\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\u56e0\u6b64\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, \\dots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\]

    \u503c\u5f97\u8bf4\u660e\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\u53ef\u4ee5\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\u8db3\u591f\u5927\uff0c\u4ee5\u5c3d\u53ef\u80fd\u6d88\u9664\u5468\u671f\u6027\u6a21\u5f0f\uff0c\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\u3001SHA-1\u3001SHA-2 \u548c SHA-3 \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\u8868 6-2 \u5c55\u793a\u4e86\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\u5e38\u89c1\u7684\u54c8\u5e0c\u7b97\u6cd5\u3002

    • MD5 \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\u3002
    • SHA-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\u7528\u5728\u5404\u7c7b\u5b89\u5168\u5e94\u7528\u4e0e\u534f\u8bae\u4e2d\u3002
    • SHA-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

    \u8868 6-2 \u00a0 \u5e38\u89c1\u7684\u54c8\u5e0c\u7b97\u6cd5

    MD5 SHA-1 SHA-2 SHA-3 \u63a8\u51fa\u65f6\u95f4 1992 1995 2002 2008 \u8f93\u51fa\u957f\u5ea6 128 bit 160 bit 256/512 bit 224/256/384/512 bit \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\u3002

    • \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\u8bfb\u8005\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig built_in_hash.py
    num = 3\nhash_num = hash(num)\n# \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\n\nbol = True\nhash_bol = hash(bol)\n# \u5e03\u5c14\u91cf True \u7684\u54c8\u5e0c\u503c\u4e3a 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 326484311674566659\n\nstr = \"Hello \u7b97\u6cd5\"\nhash_str = hash(str)\n# \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a 4617003410720528961\n\ntup = (12836, \"\u5c0f\u54c8\")\nhash_tup = hash(tup)\n# \u5143\u7ec4 (12836, '\u5c0f\u54c8') \u7684\u54c8\u5e0c\u503c\u4e3a 1029005403108185979\n\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.cpp
    int num = 3;\nsize_t hashNum = hash<int>()(num);\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\n\nbool bol = true;\nsize_t hashBol = hash<bool>()(bol);\n// \u5e03\u5c14\u91cf 1 \u7684\u54c8\u5e0c\u503c\u4e3a 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash<double>()(dec);\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 4614256650576692846\n\nstring str = \"Hello \u7b97\u6cd5\";\nsize_t hashStr = hash<string>()(str);\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a 15466937326284535026\n\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.java
    int num = 3;\nint hashNum = Integer.hashCode(num);\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729\n\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode();\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a -727081396\n\nObject[] arr = { 12836, \"\u5c0f\u54c8\" };\nint hashTup = Arrays.hashCode(arr);\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 1151158\n\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.cs
    int num = 3;\nint hashNum = num.GetHashCode();\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729;\n\nstring str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.GetHashCode();\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a -586107568;\n\nobject[] arr = [12836, \"\u5c0f\u54c8\"];\nint hashTup = arr.GetHashCode();\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// \u8282\u70b9\u5bf9\u8c61 0 \u7684\u54c8\u5e0c\u503c\u4e3a 39053774;\n
    built_in_hash.go
    // Go \u672a\u63d0\u4f9b\u5185\u7f6e hash code \u51fd\u6570\n
    built_in_hash.swift
    let num = 3\nlet hashNum = num.hashValue\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -2465384235396674631\n\nlet str = \"Hello \u7b97\u6cd5\"\nlet hashStr = str.hashValue\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a -7850626797806988787\n\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\n\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.js
    // JavaScript \u672a\u63d0\u4f9b\u5185\u7f6e hash code \u51fd\u6570\n
    built_in_hash.ts
    // TypeScript \u672a\u63d0\u4f9b\u5185\u7f6e hash code \u51fd\u6570\n
    built_in_hash.dart
    int num = 3;\nint hashNum = num.hashCode;\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// \u5e03\u5c14\u503c true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 2570631074981783\n\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode;\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a 468167534\n\nList arr = [12836, \"\u5c0f\u54c8\"];\nint hashArr = arr.hashCode;\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// \u8282\u70b9\u5bf9\u8c61 Instance of 'ListNode' \u7684\u54c8\u5e0c\u503c\u4e3a 1033450432\n
    built_in_hash.rs
    use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&mut num_hasher);\nlet hash_num = num_hasher.finish();\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 2566941990314602357\n\nlet str = \"Hello \u7b97\u6cd5\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&mut str_hasher);\nlet hash_str = str_hasher.finish();\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a 16092673739211250988\n\nlet arr = (&12836, &\"\u5c0f\u54c8\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// \u5143\u7ec4 (12836, \"\u5c0f\u54c8\") \u7684\u54c8\u5e0c\u503c\u4e3a 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&mut hasher);\nlet hash = hasher.finish();\n// \u8282\u70b9\u5bf9\u8c61 RefCell { value: ListNode { val: 42, next: None } } \u7684\u54c8\u5e0c\u503c\u4e3a15387811073369036852\n
    built_in_hash.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e hash code \u51fd\u6570\n
    built_in_hash.kt
    val num = 3\nval hashNum = num.hashCode()\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729\n\nval str = \"Hello \u7b97\u6cd5\"\nval hashStr = str.hashCode()\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a -727081396\n\nval arr = arrayOf<Any>(12836, \"\u5c0f\u54c8\")\nval hashTup = arr.hashCode()\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// \u8282\u70b9\u5bf9\u8c61 utils.ListNode@1d81eb93 \u7684\u54c8\u5e0c\u503c\u4e3a 495053715\n
    built_in_hash.rb
    \n
    built_in_hash.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5728\u8bb8\u591a\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\u6bd4\u5982\u94fe\u8868\u8282\u70b9\uff09\u7684\u6210\u5458\u53d8\u91cf\u662f\u53ef\u53d8\u7684\uff0c\u4f46\u5b83\u662f\u53ef\u54c8\u5e0c\u7684\u3002\u8fd9\u662f\u56e0\u4e3a\u5bf9\u8c61\u7684\u54c8\u5e0c\u503c\u901a\u5e38\u662f\u57fa\u4e8e\u5185\u5b58\u5730\u5740\u751f\u6210\u7684\uff0c\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

    \u7ec6\u5fc3\u7684\u4f60\u53ef\u80fd\u53d1\u73b0\u5728\u4e0d\u540c\u63a7\u5236\u53f0\u4e2d\u8fd0\u884c\u7a0b\u5e8f\u65f6\uff0c\u8f93\u51fa\u7684\u54c8\u5e0c\u503c\u662f\u4e0d\u540c\u7684\u3002\u8fd9\u662f\u56e0\u4e3a 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\u8fd9\u79cd\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\u4e00\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\u7406\u8bba\u4e0a\u54c8\u5e0c\u51b2\u7a81\u662f\u4e0d\u53ef\u907f\u514d\u7684\u3002\u6bd4\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\u6876\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\u4e86\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6bcf\u5f53\u9047\u5230\u54c8\u5e0c\u51b2\u7a81\u65f6\uff0c\u6211\u4eec\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\u53ef\u4ee5\u91c7\u7528\u4ee5\u4e0b\u7b56\u7565\u3002

    1. \u6539\u826f\u54c8\u5e0c\u8868\u6570\u636e\u7ed3\u6784\uff0c\u4f7f\u5f97\u54c8\u5e0c\u8868\u53ef\u4ee5\u5728\u51fa\u73b0\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\u624d\u6267\u884c\u6269\u5bb9\u64cd\u4f5c\u3002

    \u54c8\u5e0c\u8868\u7684\u7ed3\u6784\u6539\u826f\u65b9\u6cd5\u4e3b\u8981\u5305\u62ec\u201c\u94fe\u5f0f\u5730\u5740\u201d\u548c\u201c\u5f00\u653e\u5bfb\u5740\u201d\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\u56fe 6-5 \u5c55\u793a\u4e86\u4e00\u4e2a\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\u7684\u4f8b\u5b50\u3002

    \u56fe 6-5 \u00a0 \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868

    \u57fa\u4e8e\u94fe\u5f0f\u5730\u5740\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\u7684\u64cd\u4f5c\u65b9\u6cd5\u53d1\u751f\u4e86\u4ee5\u4e0b\u53d8\u5316\u3002

    • \u67e5\u8be2\u5143\u7d20\uff1a\u8f93\u5165 key \uff0c\u7ecf\u8fc7\u54c8\u5e0c\u51fd\u6570\u5f97\u5230\u6876\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\u9996\u5148\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u8bbf\u95ee\u94fe\u8868\u5934\u8282\u70b9\uff0c\u7136\u540e\u5c06\u8282\u70b9\uff08\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\u5e76\u5c06\u5176\u5220\u9664\u3002

    \u94fe\u5f0f\u5730\u5740\u5b58\u5728\u4ee5\u4e0b\u5c40\u9650\u6027\u3002

    • \u5360\u7528\u7a7a\u95f4\u589e\u5927\uff1a\u94fe\u8868\u5305\u542b\u8282\u70b9\u6307\u9488\uff0c\u5b83\u76f8\u6bd4\u6570\u7ec4\u66f4\u52a0\u8017\u8d39\u5185\u5b58\u7a7a\u95f4\u3002
    • \u67e5\u8be2\u6548\u7387\u964d\u4f4e\uff1a\u56e0\u4e3a\u9700\u8981\u7ebf\u6027\u904d\u5386\u94fe\u8868\u6765\u67e5\u627e\u5bf9\u5e94\u5143\u7d20\u3002

    \u4ee5\u4e0b\u4ee3\u7801\u7ed9\u51fa\u4e86\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\u7684\u7b80\u5355\u5b9e\u73b0\uff0c\u9700\u8981\u6ce8\u610f\u4e24\u70b9\u3002

    • \u4f7f\u7528\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\u4ee3\u66ff\u94fe\u8868\uff0c\u4ece\u800c\u7b80\u5316\u4ee3\u7801\u3002\u5728\u8fd9\u79cd\u8bbe\u5b9a\u4e0b\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\u5b9e\u73b0\u5305\u542b\u54c8\u5e0c\u8868\u6269\u5bb9\u65b9\u6cd5\u3002\u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7 \\(\\frac{2}{3}\\) \u65f6\uff0c\u6211\u4eec\u5c06\u54c8\u5e0c\u8868\u6269\u5bb9\u81f3\u539f\u5148\u7684 \\(2\\) \u500d\u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map_chaining.py
    class HashMapChaining:\n    \"\"\"\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\n        self.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\n        self.load_thres = 2.0 / 3.0  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        self.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\n        self.buckets = [[] for _ in range(self.capacity)]  # \u6876\u6570\u7ec4\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -> float:\n        \"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -> str | None:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        return None\n\n    def 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\n        if self.load_factor() > self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n        # \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        buckets = self.buckets\n        # \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -> \" + pair.val)\n            print(res)\n
    hash_map_chaining.cpp
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n  private:\n    int size;                       // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;                   // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres;               // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;                // \u6269\u5bb9\u500d\u6570\n    vector<vector<Pair *>> buckets; // \u6876\u6570\u7ec4\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~HashMapChaining() {\n        for (auto &bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // \u91ca\u653e\u5185\u5b58\n                delete pair;\n            }\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        int index = hashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (Pair *pair : buckets[index]) {\n            if (pair->key == key) {\n                return pair->val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n        return \"\";\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (Pair *pair : buckets[index]) {\n            if (pair->key == key) {\n                pair->val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &bucket = buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (int i = 0; i < bucket.size(); i++) {\n            if (bucket[i]->key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n                delete tmp;                       // \u91ca\u653e\u5185\u5b58\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        vector<vector<Pair *>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (auto &bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair->key, pair->val);\n                // \u91ca\u653e\u5185\u5b58\n                delete pair;\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (auto &bucket : buckets) {\n            cout << \"[\";\n            for (Pair *pair : bucket) {\n                cout << pair->key << \" -> \" << pair->val << \", \";\n            }\n            cout << \"]\\n\";\n        }\n    }\n};\n
    hash_map_chaining.java
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio; // \u6269\u5bb9\u500d\u6570\n    List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList<>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.add(new ArrayList<>());\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    String get(int key) {\n        int index = hashFunc(key);\n        List<Pair> bucket = buckets.get(index);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, String val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List<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\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List<Pair> bucket = buckets.get(index);\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        List<List<Pair>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new ArrayList<>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.add(new ArrayList<>());\n        }\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (List<Pair> bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (List<Pair> bucket : buckets) {\n            List<String> res = new ArrayList<>();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -> \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n
    hash_map_chaining.cs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio; // \u6269\u5bb9\u500d\u6570\n    List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List<List<Pair>>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (LoadFactor() > loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void Extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        List<List<Pair>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new List<List<Pair>>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        foreach (List<Pair> bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (List<Pair> bucket in buckets) {\n            List<string> res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -> \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n
    hash_map_chaining.go
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntype hashMapChaining struct {\n    size        int      // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity    int      // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    loadThres   float64  // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extendRatio int      // \u6269\u5bb9\u500d\u6570\n    buckets     [][]pair // \u6876\u6570\u7ec4\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i < 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n    return \"\"\n}\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\n    if m.loadFactor() > m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // \u5207\u7247\u5220\u9664\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i < len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i < m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -> \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n
    hash_map_chaining.swift
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    var loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    var extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: [[Pair]] // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    func hashFunc(key: Int) -> Int {\n        key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    func loadFactor() -> Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de nil\n        return nil\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if loadFactor() > loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    func extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -> \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n
    hash_map_chaining.js
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    #size; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio; // \u6269\u5bb9\u500d\u6570\n    #buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key, val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (let i = 0; i < bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -> ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n
    hash_map_chaining.ts
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    #size: number; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity: number; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres: number; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio: number; // \u6269\u5bb9\u500d\u6570\n    #buckets: Pair[][]; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key: number, val: string): void {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (let i = 0; i < bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend(): void {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -> ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n
    hash_map_chaining.dart
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n  late int size; // \u952e\u503c\u5bf9\u6570\u91cf\n  late int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n  late double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n  late int extendRatio; // \u6269\u5bb9\u500d\u6570\n  late List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) => []);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* \u8d1f\u8f7d\u56e0\u5b50 */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List<Pair> bucket = buckets[index];\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n    return null;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor() > loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List<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\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List<Pair> bucket = buckets[index];\n    // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n  void extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    List<List<Pair>> bucketsTmp = buckets;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) => []);\n    size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (List<Pair> bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (List<Pair> bucket in buckets) {\n      List<String> res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -> ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n
    hash_map_chaining.rs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nstruct HashMapChaining {\n    size: i32,\n    capacity: i32,\n    load_thres: f32,\n    extend_ratio: i32,\n    buckets: Vec<Vec<Pair>>,\n}\n\nimpl HashMapChaining {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new() -> Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        key as usize % self.capacity as usize\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fn load_factor(&self) -> f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fn remove(&mut self, key: i32) -> Option<String> {\n        let index = self.hash_func(key);\n        let bucket = &mut self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for i in 0..bucket.len() {\n            if bucket[i].key == key {\n                let pair = bucket.remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        None\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fn extend(&mut self) {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let buckets_tmp = std::mem::replace(&mut self.buckets, vec![]);\n\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fn print(&self) {\n        for bucket in &self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -> {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fn put(&mut self, key: i32, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if self.load_factor() > self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n        let bucket = &mut self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val.clone();\n                return;\n            }\n        }\n        let bucket = &mut self.buckets[index];\n\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        let pair = Pair {\n            key,\n            val: val.clone(),\n        };\n        bucket.push(pair);\n        self.size += 1;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fn get(&self, key: i32) -> Option<&str> {\n        let index = self.hash_func(key);\n        let bucket = &self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket {\n            if pair.key == key {\n                return Some(&pair.val);\n            }\n        }\n\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        None\n    }\n}\n
    hash_map_chaining.c
    /* \u94fe\u8868\u8282\u70b9 */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntypedef struct {\n    int size;         // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;  // \u6269\u5bb9\u500d\u6570\n    Node **buckets;   // \u6876\u6570\u7ec4\n} HashMapChaining;\n\n/* \u6784\u9020\u51fd\u6570 */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap->size = 0;\n    hashMap->capacity = 4;\n    hashMap->loadThres = 2.0 / 3.0;\n    hashMap->extendRatio = 2;\n    hashMap->buckets = (Node **)malloc(hashMap->capacity * sizeof(Node *));\n    for (int i = 0; i < hashMap->capacity; i++) {\n        hashMap->buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Node *cur = hashMap->buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur->next;\n            free(tmp->pair);\n            free(tmp);\n        }\n    }\n    free(hashMap->buckets);\n    free(hashMap);\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap->capacity;\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap->size / (double)hashMap->capacity;\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    Node *cur = hashMap->buckets[index];\n    while (cur) {\n        if (cur->pair->key == key) {\n            return cur->pair->val;\n        }\n        cur = cur->next;\n    }\n    return \"\"; // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor(hashMap) > hashMap->loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n    Node *cur = hashMap->buckets[index];\n    while (cur) {\n        if (cur->pair->key == key) {\n            strcpy(cur->pair->val, val); // \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n            return;\n        }\n        cur = cur->next;\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair->key = key;\n    strcpy(newPair->val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode->pair = newPair;\n    newNode->next = hashMap->buckets[index];\n    hashMap->buckets[index] = newNode;\n    hashMap->size++;\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend(HashMapChaining *hashMap) {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    int oldCapacity = hashMap->capacity;\n    Node **oldBuckets = hashMap->buckets;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    hashMap->capacity *= hashMap->extendRatio;\n    hashMap->buckets = (Node **)malloc(hashMap->capacity * sizeof(Node *));\n    for (int i = 0; i < hashMap->capacity; i++) {\n        hashMap->buckets[i] = NULL;\n    }\n    hashMap->size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (int i = 0; i < oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur->pair->key, cur->pair->val);\n            Node *temp = cur;\n            cur = cur->next;\n            // \u91ca\u653e\u5185\u5b58\n            free(temp->pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap->buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur->pair->key == key) {\n            // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n            if (pre) {\n                pre->next = cur->next;\n            } else {\n                hashMap->buckets[index] = cur->next;\n            }\n            // \u91ca\u653e\u5185\u5b58\n            free(cur->pair);\n            free(cur);\n            hashMap->size--;\n            return;\n        }\n        pre = cur;\n        cur = cur->next;\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Node *cur = hashMap->buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -> %s, \", cur->pair->key, cur->pair->val);\n            cur = cur->next;\n        }\n        printf(\"]\\n\");\n    }\n}\n
    hash_map_chaining.kt
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining() {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    val loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    val extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: MutableList<MutableList<Pair>> // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = ArrayList(capacity)\n        for (i in 0..<capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (pair in bucket) {\n            if (pair.key == key) return pair.value\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair.value = value\n                return\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        val pair = Pair(key, value)\n        bucket.add(pair)\n        size++\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fun extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        val bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        // mutablelist \u65e0\u56fa\u5b9a\u5927\u5c0f\n        buckets = mutableListOf()\n        for (i in 0..<capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair.value)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf<String>()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair.value\n                res.add(\"$k -> $v\")\n            }\n            println(res)\n        }\n    }\n}\n
    hash_map_chaining.rb
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.zig
    [class]{HashMapChaining}-[func]{}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u5f53\u94fe\u8868\u5f88\u957f\u65f6\uff0c\u67e5\u8be2\u6548\u7387 \\(O(n)\\) \u5f88\u5dee\u3002\u6b64\u65f6\u53ef\u4ee5\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u201cAVL \u6811\u201d\u6216\u201c\u7ea2\u9ed1\u6811\u201d\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\u548c\u591a\u6b21\u54c8\u5e0c\u7b49\u3002

    \u4e0b\u9762\u4ee5\u7ebf\u6027\u63a2\u6d4b\u4e3a\u4f8b\uff0c\u4ecb\u7ecd\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\u7684\u5de5\u4f5c\u673a\u5236\u3002

    "},{"location":"chapter_hashing/hash_collision/#1","title":"1. \u00a0 \u7ebf\u6027\u63a2\u6d4b","text":"

    \u7ebf\u6027\u63a2\u6d4b\u91c7\u7528\u56fa\u5b9a\u6b65\u957f\u7684\u7ebf\u6027\u641c\u7d22\u6765\u8fdb\u884c\u63a2\u6d4b\uff0c\u5176\u64cd\u4f5c\u65b9\u6cd5\u4e0e\u666e\u901a\u54c8\u5e0c\u8868\u6709\u6240\u4e0d\u540c\u3002

    • \u63d2\u5165\u5143\u7d20\uff1a\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u8ba1\u7b97\u6876\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\u6876\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\u8fdb\u884c\u7ebf\u6027\u904d\u5386\uff0c\u76f4\u5230\u627e\u5230\u5bf9\u5e94\u5143\u7d20\uff0c\u8fd4\u56de value \u5373\u53ef\uff1b\u5982\u679c\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u76ee\u6807\u5143\u7d20\u4e0d\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u8fd4\u56de None \u3002

    \u56fe 6-6 \u5c55\u793a\u4e86\u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\uff09\u54c8\u5e0c\u8868\u7684\u952e\u503c\u5bf9\u5206\u5e03\u3002\u6839\u636e\u6b64\u54c8\u5e0c\u51fd\u6570\uff0c\u6700\u540e\u4e24\u4f4d\u76f8\u540c\u7684 key \u90fd\u4f1a\u88ab\u6620\u5c04\u5230\u76f8\u540c\u7684\u6876\u3002\u800c\u901a\u8fc7\u7ebf\u6027\u63a2\u6d4b\uff0c\u5b83\u4eec\u88ab\u4f9d\u6b21\u5b58\u50a8\u5728\u8be5\u6876\u4ee5\u53ca\u4e4b\u4e0b\u7684\u6876\u4e2d\u3002

    \u56fe 6-6 \u00a0 \u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\uff09\u54c8\u5e0c\u8868\u7684\u952e\u503c\u5bf9\u5206\u5e03

    \u7136\u800c\uff0c\u7ebf\u6027\u63a2\u6d4b\u5bb9\u6613\u4ea7\u751f\u201c\u805a\u96c6\u73b0\u8c61\u201d\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u6570\u7ec4\u4e2d\u8fde\u7eed\u88ab\u5360\u7528\u7684\u4f4d\u7f6e\u8d8a\u957f\uff0c\u8fd9\u4e9b\u8fde\u7eed\u4f4d\u7f6e\u53d1\u751f\u54c8\u5e0c\u51b2\u7a81\u7684\u53ef\u80fd\u6027\u8d8a\u5927\uff0c\u4ece\u800c\u8fdb\u4e00\u6b65\u4fc3\u4f7f\u8be5\u4f4d\u7f6e\u7684\u805a\u5806\u751f\u957f\uff0c\u5f62\u6210\u6076\u6027\u5faa\u73af\uff0c\u6700\u7ec8\u5bfc\u81f4\u589e\u5220\u67e5\u6539\u64cd\u4f5c\u6548\u7387\u52a3\u5316\u3002

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u6211\u4eec\u4e0d\u80fd\u5728\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\u4e2d\u76f4\u63a5\u5220\u9664\u5143\u7d20\u3002\u8fd9\u662f\u56e0\u4e3a\u5220\u9664\u5143\u7d20\u4f1a\u5728\u6570\u7ec4\u5185\u4ea7\u751f\u4e00\u4e2a\u7a7a\u6876 None \uff0c\u800c\u5f53\u67e5\u8be2\u5143\u7d20\u65f6\uff0c\u7ebf\u6027\u63a2\u6d4b\u5230\u8be5\u7a7a\u6876\u5c31\u4f1a\u8fd4\u56de\uff0c\u56e0\u6b64\u5728\u8be5\u7a7a\u6876\u4e4b\u4e0b\u7684\u5143\u7d20\u90fd\u65e0\u6cd5\u518d\u88ab\u8bbf\u95ee\u5230\uff0c\u7a0b\u5e8f\u53ef\u80fd\u8bef\u5224\u8fd9\u4e9b\u5143\u7d20\u4e0d\u5b58\u5728\uff0c\u5982\u56fe 6-7 \u6240\u793a\u3002

    \u56fe 6-7 \u00a0 \u5728\u5f00\u653e\u5bfb\u5740\u4e2d\u5220\u9664\u5143\u7d20\u5bfc\u81f4\u7684\u67e5\u8be2\u95ee\u9898

    \u4e3a\u4e86\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u91c7\u7528\u300c\u61d2\u5220\u9664 lazy deletion\u300d\u673a\u5236\uff1a\u5b83\u4e0d\u76f4\u63a5\u4ece\u54c8\u5e0c\u8868\u4e2d\u79fb\u9664\u5143\u7d20\uff0c\u800c\u662f\u5229\u7528\u4e00\u4e2a\u5e38\u91cf TOMBSTONE \u6765\u6807\u8bb0\u8fd9\u4e2a\u6876\u3002\u5728\u8be5\u673a\u5236\u4e0b\uff0cNone \u548c TOMBSTONE \u90fd\u4ee3\u8868\u7a7a\u6876\uff0c\u90fd\u53ef\u4ee5\u653e\u7f6e\u952e\u503c\u5bf9\u3002\u4f46\u4e0d\u540c\u7684\u662f\uff0c\u7ebf\u6027\u63a2\u6d4b\u5230 TOMBSTONE \u65f6\u5e94\u8be5\u7ee7\u7eed\u904d\u5386\uff0c\u56e0\u4e3a\u5176\u4e4b\u4e0b\u53ef\u80fd\u8fd8\u5b58\u5728\u952e\u503c\u5bf9\u3002

    \u7136\u800c\uff0c\u61d2\u5220\u9664\u53ef\u80fd\u4f1a\u52a0\u901f\u54c8\u5e0c\u8868\u7684\u6027\u80fd\u9000\u5316\u3002\u8fd9\u662f\u56e0\u4e3a\u6bcf\u6b21\u5220\u9664\u64cd\u4f5c\u90fd\u4f1a\u4ea7\u751f\u4e00\u4e2a\u5220\u9664\u6807\u8bb0\uff0c\u968f\u7740 TOMBSTONE \u7684\u589e\u52a0\uff0c\u641c\u7d22\u65f6\u95f4\u4e5f\u4f1a\u589e\u52a0\uff0c\u56e0\u4e3a\u7ebf\u6027\u63a2\u6d4b\u53ef\u80fd\u9700\u8981\u8df3\u8fc7\u591a\u4e2a TOMBSTONE \u624d\u80fd\u627e\u5230\u76ee\u6807\u5143\u7d20\u3002

    \u4e3a\u6b64\uff0c\u8003\u8651\u5728\u7ebf\u6027\u63a2\u6d4b\u4e2d\u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a TOMBSTONE \u7684\u7d22\u5f15\uff0c\u5e76\u5c06\u641c\u7d22\u5230\u7684\u76ee\u6807\u5143\u7d20\u4e0e\u8be5 TOMBSTONE \u4ea4\u6362\u4f4d\u7f6e\u3002\u8fd9\u6837\u505a\u7684\u597d\u5904\u662f\u5f53\u6bcf\u6b21\u67e5\u8be2\u6216\u6dfb\u52a0\u5143\u7d20\u65f6\uff0c\u5143\u7d20\u4f1a\u88ab\u79fb\u52a8\u81f3\u8ddd\u79bb\u7406\u60f3\u4f4d\u7f6e\uff08\u63a2\u6d4b\u8d77\u59cb\u70b9\uff09\u66f4\u8fd1\u7684\u6876\uff0c\u4ece\u800c\u4f18\u5316\u67e5\u8be2\u6548\u7387\u3002

    \u4ee5\u4e0b\u4ee3\u7801\u5b9e\u73b0\u4e86\u4e00\u4e2a\u5305\u542b\u61d2\u5220\u9664\u7684\u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\uff09\u54c8\u5e0c\u8868\u3002\u4e3a\u4e86\u66f4\u52a0\u5145\u5206\u5730\u4f7f\u7528\u54c8\u5e0c\u8868\u7684\u7a7a\u95f4\uff0c\u6211\u4eec\u5c06\u54c8\u5e0c\u8868\u770b\u4f5c\u4e00\u4e2a\u201c\u73af\u5f62\u6570\u7ec4\u201d\uff0c\u5f53\u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u56de\u5230\u5934\u90e8\u7ee7\u7eed\u904d\u5386\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map_open_addressing.py
    class HashMapOpenAddressing:\n    \"\"\"\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\n        self.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\n        self.load_thres = 2.0 / 3.0  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        self.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\n        self.buckets: list[Pair | None] = [None] * self.capacity  # \u6876\u6570\u7ec4\n        self.TOMBSTONE = Pair(-1, \"-1\")  # \u5220\u9664\u6807\u8bb0\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -> float:\n        \"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -> int:\n        \"\"\"\u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while self.buckets[index] is not None:\n            # \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if self.buckets[index].key == key:\n                # \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                return index  # \u8fd4\u56de\u6876\u7d22\u5f15\n            # \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % self.capacity\n        # \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -> str:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de None\n        return None\n\n    def 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\n        if self.load_factor() > self.load_thres:\n            self.extend()\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n        # \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        buckets_tmp = self.buckets\n        # \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"->\", pair.val)\n
    hash_map_open_addressing.cpp
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity = 4;                     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    const double loadThres = 2.0 / 3.0;     // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    const int extendRatio = 2;            // \u6269\u5bb9\u500d\u6570\n    vector<Pair *> buckets;               // \u6876\u6570\u7ec4\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr && pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != nullptr) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index]->key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            return buckets[index]->val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n        return \"\";\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            buckets[index]->val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        vector<Pair *> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = vector<Pair *>(capacity, nullptr);\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr && pair != TOMBSTONE) {\n                put(pair->key, pair->val);\n                delete pair;\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout << \"nullptr\" << endl;\n            } else if (pair == TOMBSTONE) {\n                cout << \"TOMBSTONE\" << endl;\n            } else {\n                cout << pair->key << \" -> \" << pair->val << endl;\n            }\n        }\n    }\n};\n
    hash_map_open_addressing.java
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    private int capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private final double loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private final int extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n    private Pair[] buckets; // \u6876\u6570\u7ec4\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index].key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public String get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void put(int key, String val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    private void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        Pair[] bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (Pair pair : bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -> \" + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.cs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n    Pair[] buckets; // \u6876\u6570\u7ec4\n    Pair TOMBSTONE = new(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index].key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (LoadFactor() > loadThres) {\n            Extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void Extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        Pair[] bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -> \" + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.go
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\ntype hashMapOpenAddressing struct {\n    size        int     // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity    int     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    loadThres   float64 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extendRatio int     // \u6269\u5bb9\u500d\u6570\n    buckets     []*pair // \u6876\u6570\u7ec4\n    TOMBSTONE   *pair   // \u5220\u9664\u6807\u8bb0\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &pair{-1, \"-1\"},\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // \u6839\u636e\u952e\u8ba1\u7b97\u54c8\u5e0c\u503c\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // \u8ba1\u7b97\u5f53\u524d\u8d1f\u8f7d\u56e0\u5b50\n}\n\n/* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // \u83b7\u53d6\u521d\u59cb\u7d22\u5f15\n    firstTombstone := -1     // \u8bb0\u5f55\u9047\u5230\u7684\u7b2c\u4e00\u4e2aTOMBSTONE\u7684\u4f4d\u7f6e\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n            }\n            return index // \u8fd4\u56de\u627e\u5230\u7684\u7d22\u5f15\n        }\n        if firstTombstone == -1 && h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\u7684\u4f4d\u7f6e\n        }\n        index = (index + 1) % h.capacity // \u7ebf\u6027\u63a2\u6d4b\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    }\n    return \"\" // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de \"\"\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() > h.loadThres {\n        h.extend() // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    }\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &pair{key, val} // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        h.size++\n    } else {\n        h.buckets[index].val = val // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val\n    }\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        h.size--\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    h.capacity *= h.extendRatio           // \u66f4\u65b0\u5bb9\u91cf\n    h.buckets = make([]*pair, h.capacity) // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    h.size = 0                            // \u91cd\u7f6e\u5927\u5c0f\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for _, pair := range oldBuckets {\n        if pair != nil && pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -> %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n
    hash_map_open_addressing.swift
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    var loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    var extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: [Pair?] // \u6876\u6570\u7ec4\n    var TOMBSTONE: Pair // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    func hashFunc(key: Int) -> Int {\n        key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    func loadFactor() -> Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    func findBucket(key: Int) -> Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while buckets[index] != nil {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if buckets[index]!.key == key {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if firstTombstone == -1 && buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return nil\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if loadFactor() > loadThres {\n            extend()\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    func extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -> \\(pair!.val)\")\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.js
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    #size; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio; // \u6269\u5bb9\u500d\u6570\n    #buckets; // \u6876\u6570\u7ec4\n    #TOMBSTONE; // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0; // \u952e\u503c\u5bf9\u6570\u91cf\n        this.#capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n        this.#loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        this.#extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n        this.#buckets = Array(this.#capacity).fill(null); // \u6876\u6570\u7ec4\n        this.#TOMBSTONE = new Pair(-1, '-1'); // \u5220\u9664\u6807\u8bb0\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (this.#buckets[index] !== null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (this.#buckets[index].key === key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (\n                firstTombstone === -1 &&\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % this.#capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key, val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const pair of bucketsTmp) {\n            if (pair !== null && pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -> ' + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.ts
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private size: number; // \u952e\u503c\u5bf9\u6570\u91cf\n    private capacity: number; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private loadThres: number; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private extendRatio: number; // \u6269\u5bb9\u500d\u6570\n    private buckets: Array<Pair | null>; // \u6876\u6570\u7ec4\n    private TOMBSTONE: Pair; // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.size = 0; // \u952e\u503c\u5bf9\u6570\u91cf\n        this.capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n        this.loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        this.extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n        this.buckets = Array(this.capacity).fill(null); // \u6876\u6570\u7ec4\n        this.TOMBSTONE = new Pair(-1, '-1'); // \u5220\u9664\u6807\u8bb0\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (this.buckets[index] !== null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (this.buckets[index]!.key === key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (\n                firstTombstone === -1 &&\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % this.capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key: number): string | null {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key: number, val: string): void {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.loadFactor() > this.loadThres) {\n            this.extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key: number): void {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    private extend(): void {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const pair of bucketsTmp) {\n            if (pair !== null && pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -> ' + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.dart
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n  late int _size; // \u952e\u503c\u5bf9\u6570\u91cf\n  int _capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n  double _loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n  int _extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n  late List<Pair?> _buckets; // \u6876\u6570\u7ec4\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) => null);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* \u8d1f\u8f7d\u56e0\u5b50 */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n    while (_buckets[index] != null) {\n      // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n      if (_buckets[index]!.key == key) {\n        // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n        }\n        return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n      }\n      // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n      if (firstTombstone == -1 && _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n      index = (index + 1) % _capacity;\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n    return null;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor() > _loadThres) {\n      extend();\n    }\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n  void extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    List<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\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null && pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -> ${pair.val}\");\n      }\n    }\n  }\n}\n
    hash_map_open_addressing.rs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nstruct HashMapOpenAddressing {\n    size: usize,                // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity: usize,            // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    load_thres: f64,            // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extend_ratio: usize,        // \u6269\u5bb9\u500d\u6570\n    buckets: Vec<Option<Pair>>, // \u6876\u6570\u7ec4\n    TOMBSTONE: Option<Pair>,    // \u5220\u9664\u6807\u8bb0\n}\n\nimpl HashMapOpenAddressing {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new() -> Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fn load_factor(&self) -> f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    fn find_bucket(&mut self, key: i32) -> usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while self.buckets[index].is_some() {\n            // \u82e5\u9047\u5230 key\uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u5efa\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if first_tombstone == -1 && self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % self.capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fn get(&mut self, key: i32) -> Option<&str> {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &pair.val as &str);\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        None\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fn put(&mut self, key: i32, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if self.load_factor() > self.load_thres {\n            self.extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fn remove(&mut self, key: i32) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fn extend(&mut self) {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let buckets_tmp = self.buckets.clone();\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fn print(&self) {\n        for pair in &self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -> {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.c
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\ntypedef struct {\n    int size;         // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;  // \u6269\u5bb9\u500d\u6570\n    Pair **buckets;   // \u6876\u6570\u7ec4\n    Pair *TOMBSTONE;  // \u5220\u9664\u6807\u8bb0\n} HashMapOpenAddressing;\n\n/* \u6784\u9020\u51fd\u6570 */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap->size = 0;\n    hashMap->capacity = 4;\n    hashMap->loadThres = 2.0 / 3.0;\n    hashMap->extendRatio = 2;\n    hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);\n    hashMap->TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap->TOMBSTONE->key = -1;\n    hashMap->TOMBSTONE->val = \"-1\";\n\n    return hashMap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Pair *pair = hashMap->buckets[i];\n        if (pair != NULL && pair != hashMap->TOMBSTONE) {\n            free(pair->val);\n            free(pair);\n        }\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap->capacity;\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap->size / (double)hashMap->capacity;\n}\n\n/* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n    while (hashMap->buckets[index] != NULL) {\n        // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        if (hashMap->buckets[index]->key == key) {\n            // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n            if (firstTombstone != -1) {\n                hashMap->buckets[firstTombstone] = hashMap->buckets[index];\n                hashMap->buckets[index] = hashMap->TOMBSTONE;\n                return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n            }\n            return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n        }\n        // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n        if (firstTombstone == -1 && hashMap->buckets[index] == hashMap->TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n        index = (index + 1) % hashMap->capacity;\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        return hashMap->buckets[index]->val;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n    return \"\";\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor(hashMap) > hashMap->loadThres) {\n        extend(hashMap);\n    }\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        free(hashMap->buckets[index]->val);\n        hashMap->buckets[index]->val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap->buckets[index]->val, val);\n        hashMap->buckets[index]->val[strlen(val)] = '\\0';\n        return;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair->key = key;\n    pair->val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair->val, val);\n    pair->val[strlen(val)] = '\\0';\n\n    hashMap->buckets[index] = pair;\n    hashMap->size++;\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        Pair *pair = hashMap->buckets[index];\n        free(pair->val);\n        free(pair);\n        hashMap->buckets[index] = hashMap->TOMBSTONE;\n        hashMap->size--;\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    Pair **bucketsTmp = hashMap->buckets;\n    int oldCapacity = hashMap->capacity;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    hashMap->capacity *= hashMap->extendRatio;\n    hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);\n    hashMap->size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (int i = 0; i < oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL && pair != hashMap->TOMBSTONE) {\n            put(hashMap, pair->key, pair->val);\n            free(pair->val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Pair *pair = hashMap->buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap->TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -> %s\\n\", pair->key, pair->val);\n        }\n    }\n}\n
    hash_map_open_addressing.kt
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private var size: Int = 0 // \u952e\u503c\u5bf9\u6570\u91cf\n    private var capacity = 4 // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private val loadThres: Double = 2.0 / 3.0 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private val extendRatio = 2 // \u6269\u5bb9\u500d\u6570\n    private var buckets: Array<Pair?> // \u6876\u6570\u7ec4\n    private val TOMBSTONE = Pair(-1, \"-1\") // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init {\n        buckets = arrayOfNulls(capacity)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index]?.key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index]?.value\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend()\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index]!!.value = value\n            return\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = Pair(key, value)\n        size++\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fun extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        val bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (pair in bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                put(pair.key, pair.value)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -> ${pair.value}\")\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.rb
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.zig
    [class]{HashMapOpenAddressing}-[func]{}\n
    "},{"location":"chapter_hashing/hash_collision/#2","title":"2. \u00a0 \u5e73\u65b9\u63a2\u6d4b","text":"

    \u5e73\u65b9\u63a2\u6d4b\u4e0e\u7ebf\u6027\u63a2\u6d4b\u7c7b\u4f3c\uff0c\u90fd\u662f\u5f00\u653e\u5bfb\u5740\u7684\u5e38\u89c1\u7b56\u7565\u4e4b\u4e00\u3002\u5f53\u53d1\u751f\u51b2\u7a81\u65f6\uff0c\u5e73\u65b9\u63a2\u6d4b\u4e0d\u662f\u7b80\u5355\u5730\u8df3\u8fc7\u4e00\u4e2a\u56fa\u5b9a\u7684\u6b65\u6570\uff0c\u800c\u662f\u8df3\u8fc7\u201c\u63a2\u6d4b\u6b21\u6570\u7684\u5e73\u65b9\u201d\u7684\u6b65\u6570\uff0c\u5373 \\(1, 4, 9, \\dots\\) \u6b65\u3002

    \u5e73\u65b9\u63a2\u6d4b\u4e3b\u8981\u5177\u6709\u4ee5\u4e0b\u4f18\u52bf\u3002

    • \u5e73\u65b9\u63a2\u6d4b\u901a\u8fc7\u8df3\u8fc7\u63a2\u6d4b\u6b21\u6570\u5e73\u65b9\u7684\u8ddd\u79bb\uff0c\u8bd5\u56fe\u7f13\u89e3\u7ebf\u6027\u63a2\u6d4b\u7684\u805a\u96c6\u6548\u5e94\u3002
    • \u5e73\u65b9\u63a2\u6d4b\u4f1a\u8df3\u8fc7\u66f4\u5927\u7684\u8ddd\u79bb\u6765\u5bfb\u627e\u7a7a\u4f4d\u7f6e\uff0c\u6709\u52a9\u4e8e\u6570\u636e\u5206\u5e03\u5f97\u66f4\u52a0\u5747\u5300\u3002

    \u7136\u800c\uff0c\u5e73\u65b9\u63a2\u6d4b\u5e76\u4e0d\u662f\u5b8c\u7f8e\u7684\u3002

    • \u4ecd\u7136\u5b58\u5728\u805a\u96c6\u73b0\u8c61\uff0c\u5373\u67d0\u4e9b\u4f4d\u7f6e\u6bd4\u5176\u4ed6\u4f4d\u7f6e\u66f4\u5bb9\u6613\u88ab\u5360\u7528\u3002
    • \u7531\u4e8e\u5e73\u65b9\u7684\u589e\u957f\uff0c\u5e73\u65b9\u63a2\u6d4b\u53ef\u80fd\u4e0d\u4f1a\u63a2\u6d4b\u6574\u4e2a\u54c8\u5e0c\u8868\uff0c\u8fd9\u610f\u5473\u7740\u5373\u4f7f\u54c8\u5e0c\u8868\u4e2d\u6709\u7a7a\u6876\uff0c\u5e73\u65b9\u63a2\u6d4b\u4e5f\u53ef\u80fd\u65e0\u6cd5\u8bbf\u95ee\u5230\u5b83\u3002
    "},{"location":"chapter_hashing/hash_collision/#3","title":"3. \u00a0 \u591a\u6b21\u54c8\u5e0c","text":"

    \u987e\u540d\u601d\u4e49\uff0c\u591a\u6b21\u54c8\u5e0c\u65b9\u6cd5\u4f7f\u7528\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570 \\(f_1(x)\\)\u3001\\(f_2(x)\\)\u3001\\(f_3(x)\\)\u3001\\(\\dots\\) \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\u82e5\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 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\u5e26\u6765\u989d\u5916\u7684\u8ba1\u7b97\u91cf\u3002

    Tip

    \u8bf7\u6ce8\u610f\uff0c\u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\u3001\u5e73\u65b9\u63a2\u6d4b\u548c\u591a\u6b21\u54c8\u5e0c\uff09\u54c8\u5e0c\u8868\u90fd\u5b58\u5728\u201c\u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u201d\u7684\u95ee\u9898\u3002

    "},{"location":"chapter_hashing/hash_collision/#623","title":"6.2.3 \u00a0 \u7f16\u7a0b\u8bed\u8a00\u7684\u9009\u62e9","text":"

    \u5404\u79cd\u7f16\u7a0b\u8bed\u8a00\u91c7\u53d6\u4e86\u4e0d\u540c\u7684\u54c8\u5e0c\u8868\u5b9e\u73b0\u7b56\u7565\uff0c\u4e0b\u9762\u4e3e\u51e0\u4e2a\u4f8b\u5b50\u3002

    • Python \u91c7\u7528\u5f00\u653e\u5bfb\u5740\u3002\u5b57\u5178 dict \u4f7f\u7528\u4f2a\u968f\u673a\u6570\u8fdb\u884c\u63a2\u6d4b\u3002
    • 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\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u4ee5\u63d0\u5347\u67e5\u627e\u6027\u80fd\u3002
    • Go \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\uff0c\u53c8\u79f0\u300c\u6563\u5217\u8868\u300d\uff0c\u5b83\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\u4e2d\u8f93\u5165\u4e00\u4e2a\u952e key \uff0c\u5219\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u83b7\u53d6\u5bf9\u5e94\u7684\u503c value \u3002

    \u5982\u56fe 6-1 \u6240\u793a\uff0c\u7ed9\u5b9a \\(n\\) \u4e2a\u5b66\u751f\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\u56fe 6-1 \u6240\u793a\u7684\u54c8\u5e0c\u8868\u6765\u5b9e\u73b0\u3002

    \u56fe 6-1 \u00a0 \u54c8\u5e0c\u8868\u7684\u62bd\u8c61\u8868\u793a

    \u9664\u54c8\u5e0c\u8868\u5916\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u4e5f\u53ef\u4ee5\u5b9e\u73b0\u67e5\u8be2\u529f\u80fd\uff0c\u5b83\u4eec\u7684\u6548\u7387\u5bf9\u6bd4\u5982\u8868 6-1 \u6240\u793a\u3002

    • \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\u3002
    • \u67e5\u8be2\u5143\u7d20\uff1a\u7531\u4e8e\u6570\u7ec4\uff08\u94fe\u8868\uff09\u662f\u4e71\u5e8f\u7684\uff0c\u56e0\u6b64\u9700\u8981\u904d\u5386\u5176\u4e2d\u7684\u6240\u6709\u5143\u7d20\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002
    • \u5220\u9664\u5143\u7d20\uff1a\u9700\u8981\u5148\u67e5\u8be2\u5230\u5143\u7d20\uff0c\u518d\u4ece\u6570\u7ec4\uff08\u94fe\u8868\uff09\u4e2d\u5220\u9664\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002

    \u8868 6-1 \u00a0 \u5143\u7d20\u67e5\u8be2\u6548\u7387\u5bf9\u6bd4

    \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

    "},{"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\uff0c\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map.py
    # \u521d\u59cb\u5316\u54c8\u5e0c\u8868\nhmap: dict = {}\n\n# \u6dfb\u52a0\u64cd\u4f5c\n# \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nhmap[12836] = \"\u5c0f\u54c8\"\nhmap[15937] = \"\u5c0f\u5570\"\nhmap[16750] = \"\u5c0f\u7b97\"\nhmap[13276] = \"\u5c0f\u6cd5\"\nhmap[10583] = \"\u5c0f\u9e2d\"\n\n# \u67e5\u8be2\u64cd\u4f5c\n# \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nname: str = hmap[15937]\n\n# \u5220\u9664\u64cd\u4f5c\n# \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nhmap.pop(10583)\n
    hash_map.cpp
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nunordered_map<int, string> map;\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nstring name = map[15937];\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.erase(10583);\n
    hash_map.java
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nMap<Integer, String> map = new HashMap<>();\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.put(12836, \"\u5c0f\u54c8\");   \nmap.put(15937, \"\u5c0f\u5570\");   \nmap.put(16750, \"\u5c0f\u7b97\");   \nmap.put(13276, \"\u5c0f\u6cd5\");\nmap.put(10583, \"\u5c0f\u9e2d\");\n\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map.get(15937);\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583);\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)\n    { 12836, \"\u5c0f\u54c8\" },\n    { 15937, \"\u5c0f\u5570\" },\n    { 16750, \"\u5c0f\u7b97\" },\n    { 13276, \"\u5c0f\u6cd5\" },\n    { 10583, \"\u5c0f\u9e2d\" }\n};\n\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nstring name = map[15937];\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.Remove(10583);\n
    hash_map_test.go
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nhmap := make(map[int]string)\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nhmap[12836] = \"\u5c0f\u54c8\"\nhmap[15937] = \"\u5c0f\u5570\"\nhmap[16750] = \"\u5c0f\u7b97\"\nhmap[13276] = \"\u5c0f\u6cd5\"\nhmap[10583] = \"\u5c0f\u9e2d\"\n\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nname := hmap[15937]\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\ndelete(hmap, 10583)\n
    hash_map.swift
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nvar map: [Int: String] = [:]\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map[15937]!\n\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.js
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nconst map = new Map();\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map.get(15937);\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\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\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.dart
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nMap<int, String> map = {};\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map[15937];\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583);\n
    hash_map.rs
    use std::collections::HashMap;\n\n/* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nlet mut map: HashMap<i32, String> = HashMap::new();\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.insert(12836, \"\u5c0f\u54c8\".to_string());\nmap.insert(15937, \"\u5c0f\u5570\".to_string());\nmap.insert(16750, \"\u5c0f\u7b97\".to_string());\nmap.insert(13279, \"\u5c0f\u6cd5\".to_string());\nmap.insert(10583, \"\u5c0f\u9e2d\".to_string());\n\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet _name: Option<&String> = map.get(&15937);\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nlet _removed_value: Option<String> = map.remove(&10583);\n
    hash_map.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u8868\n
    hash_map.kt
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nval map = HashMap<Int,String>()\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nval name = map[15937]\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583)\n
    hash_map.rb
    \n
    hash_map.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u54c8\u5e0c\u8868\u6709\u4e09\u79cd\u5e38\u7528\u7684\u904d\u5386\u65b9\u5f0f\uff1a\u904d\u5386\u952e\u503c\u5bf9\u3001\u904d\u5386\u952e\u548c\u904d\u5386\u503c\u3002\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map.py
    # \u904d\u5386\u54c8\u5e0c\u8868\n# \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor key, value in hmap.items():\n    print(key, \"->\", value)\n# \u5355\u72ec\u904d\u5386\u952e key\nfor key in hmap.keys():\n    print(key)\n# \u5355\u72ec\u904d\u5386\u503c value\nfor value in hmap.values():\n    print(value)\n
    hash_map.cpp
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor (auto kv: map) {\n    cout << kv.first << \" -> \" << kv.second << endl;\n}\n// \u4f7f\u7528\u8fed\u4ee3\u5668\u904d\u5386 key->value\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout << iter->first << \"->\" << iter->second << endl;\n}\n
    hash_map.java
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor (Map.Entry <Integer, String> kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -> \" + kv.getValue());\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n
    hash_map.cs
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -> \" + kv.Value);\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n
    hash_map_test.go
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor key, value := range hmap {\n    fmt.Println(key, \"->\", value)\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor key := range hmap {\n    fmt.Println(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n
    hash_map.swift
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nfor (key, value) in map {\n    print(\"\\(key) -> \\(value)\")\n}\n// \u5355\u72ec\u904d\u5386\u952e Key\nfor key in map.keys {\n    print(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c Value\nfor value in map.values {\n    print(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()) {\n    console.info(k + ' -> ' + v);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u952e Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u503c Value');\nfor (const v of map.values()) {\n    console.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()) {\n    console.info(k + ' -> ' + v);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u952e Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u503c Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n
    hash_map.dart
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nmap.forEach((key, value) {\n  print('$key -> $value');\n});\n\n// \u5355\u72ec\u904d\u5386\u952e Key\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// \u5355\u72ec\u904d\u5386\u503c Value\nmap.values.forEach((value) {\n  print(value);\n});\n
    hash_map.rs
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nfor (key, value) in &map {\n    println!(\"{key} -> {value}\");\n}\n\n// \u5355\u72ec\u904d\u5386\u952e Key\nfor key in map.keys() {\n    println!(\"{key}\"); \n}\n\n// \u5355\u72ec\u904d\u5386\u503c Value\nfor value in map.values() {\n    println!(\"{value}\");\n}\n
    hash_map.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u8868\n
    hash_map.kt
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor ((key, value) in map) {\n    println(\"$key -> $value\")\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor (key in map.keys) {\n    println(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor (_val in map.values) {\n    println(_val)\n}\n
    hash_map.rb
    \n
    hash_map.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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 \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\u4ee5\u4e0b\u4e24\u6b65\u3002

    1. \u901a\u8fc7\u67d0\u79cd\u54c8\u5e0c\u7b97\u6cd5 hash() \u8ba1\u7b97\u5f97\u5230\u54c8\u5e0c\u503c\u3002
    2. \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\u56fe 6-2 \u4ee5 key \u5b66\u53f7\u548c value \u59d3\u540d\u4e3a\u4f8b\uff0c\u5c55\u793a\u4e86\u54c8\u5e0c\u51fd\u6570\u7684\u5de5\u4f5c\u539f\u7406\u3002

    \u56fe 6-2 \u00a0 \u54c8\u5e0c\u51fd\u6570\u5de5\u4f5c\u539f\u7406

    \u4ee5\u4e0b\u4ee3\u7801\u5b9e\u73b0\u4e86\u4e00\u4e2a\u7b80\u5355\u54c8\u5e0c\u8868\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_hash_map.py
    class Pair:\n    \"\"\"\u952e\u503c\u5bf9\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        # \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -> str:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        index: int = self.hash_func(key)\n        # \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\n        self.buckets[index] = None\n\n    def entry_set(self) -> list[Pair]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -> list[int]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u952e\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -> list[str]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u503c\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"->\", pair.val)\n
    array_hash_map.cpp
    /* \u952e\u503c\u5bf9 */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this->key = key;\n        this->val = val;\n    }\n};\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n  private:\n    vector<Pair *> buckets;\n\n  public:\n    ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = vector<Pair *>(100);\n    }\n\n    ~ArrayHashMap() {\n        // \u91ca\u653e\u5185\u5b58\n        for (const auto &bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair->val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // \u91ca\u653e\u5185\u5b58\u5e76\u7f6e\u4e3a nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    vector<Pair *> pairSet() {\n        vector<Pair *> pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    vector<int> keySet() {\n        vector<int> keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair->key);\n            }\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    vector<string> valueSet() {\n        vector<string> valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair->val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout << kv->key << \" -> \" << kv->val << endl;\n        }\n    }\n};\n
    array_hash_map.java
    /* \u952e\u503c\u5bf9 */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private List<Pair> buckets;\n\n    public ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = new ArrayList<>();\n        for (int i = 0; i < 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets.set(index, null);\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public List<Pair> pairSet() {\n        List<Pair> pairSet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public List<Integer> keySet() {\n        List<Integer> keySet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public List<String> valueSet() {\n        List<String> valueSet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -> \" + kv.val);\n        }\n    }\n}\n
    array_hash_map.cs
    /* \u952e\u503c\u5bf9 int->string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    List<Pair?> buckets;\n    public ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = [];\n        for (int i = 0; i < 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public List<Pair> PairSet() {\n        List<Pair> pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public List<int> KeySet() {\n        List<int> keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public List<string> ValueSet() {\n        List<string> valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -> \" + kv.val);\n        }\n    }\n}\n
    array_hash_map.go
    /* \u952e\u503c\u5bf9 */\ntype pair struct {\n    key int\n    val string\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nfunc newArrayHashMap() *arrayHashMap {\n    // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n    buckets := make([]*pair, 100)\n    return &arrayHashMap{buckets: buckets}\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\n    a.buckets[index] = nil\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e\u5bf9 */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* \u83b7\u53d6\u6240\u6709\u503c */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"->\", pair.val)\n        }\n    }\n}\n
    array_hash_map.swift
    /* \u952e\u503c\u5bf9 */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -> Bool {\n        lhs.key == rhs.key && lhs.val == rhs.val\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private func hashFunc(key: Int) -> Int {\n        let index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = nil\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    func pairSet() -> [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    func keySet() -> [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    func valueSet() -> [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -> \\(pair.val)\")\n        }\n    }\n}\n
    array_hash_map.js
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        this.#buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    entries() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    keys() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    values() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -> ${pair.val}`);\n        }\n    }\n}\n
    array_hash_map.ts
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        this.buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -> ${pair.val}`);\n        }\n    }\n}\n
    array_hash_map.dart
    /* \u952e\u503c\u5bf9 */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n  late List<Pair?> _buckets;\n\n  ArrayHashMap() {\n    // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n    _buckets = List.filled(100, null);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n  List<Pair> pairSet() {\n    List<Pair> pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u952e */\n  List<int> keySet() {\n    List<int> keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u503c */\n  List<String> values() {\n    List<String> valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -> ${kv.val}\");\n    }\n  }\n}\n
    array_hash_map.rs
    /* \u952e\u503c\u5bf9 */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\npub struct ArrayHashMap {\n    buckets: Vec<Option<Pair>>,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -> ArrayHashMap {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        key as usize % 100\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    pub fn get(&self, key: i32) -> Option<&String> {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &pair.val)\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    pub fn put(&mut self, key: i32, val: &str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    pub fn remove(&mut self, key: i32) {\n        let index = self.hash_func(key);\n        // \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\n        self.buckets[index] = None;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    pub fn entry_set(&self) -> Vec<&Pair> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    pub fn key_set(&self) -> Vec<&i32> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &pair.key))\n            .collect()\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    pub fn value_set(&self) -> Vec<&String> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &pair.val))\n            .collect()\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    pub fn print(&self) {\n        for pair in self.entry_set() {\n            println!(\"{} -> {}\", pair.key, pair.val);\n        }\n    }\n}\n
    array_hash_map.c
    /* \u952e\u503c\u5bf9 int->string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntypedef struct {\n    Pair *buckets[HASHTABLE_CAPACITY];\n} ArrayHashMap;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    return hmap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            free(hmap->buckets[i]->val);\n            free(hmap->buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair->key = key;\n    Pair->val = malloc(strlen(val) + 1);\n    strcpy(Pair->val, val);\n\n    int index = hashFunc(key);\n    hmap->buckets[index] = Pair;\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap->buckets[index]->val);\n    free(hmap->buckets[index]);\n    hmap->buckets[index] = NULL;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            entries[index].key = hmap->buckets[i]->key;\n            entries[index].val = malloc(strlen(hmap->buckets[i]->val) + 1);\n            strcpy(entries[index].val, hmap->buckets[i]->val);\n            index++;\n        }\n    }\n    set->set = entries;\n    set->len = total;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            keys[index] = hmap->buckets[i]->key;\n            index++;\n        }\n    }\n    set->set = keys;\n    set->len = total;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u503c */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            vals[index] = hmap->buckets[i]->val;\n            index++;\n        }\n    }\n    set->set = vals;\n    set->len = total;\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i < set.len; i++) {\n        printf(\"%d -> %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n
    array_hash_map.kt
    /* \u952e\u503c\u5bf9 */\nclass Pair(\n    var key: Int,\n    var value: String\n)\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private val buckets = arrayOfNulls<Pair>(100)\n\n    init {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        for (i in 0..<100) {\n            buckets[i] = null\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair.value\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        val pair = Pair(key, value)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    fun pairSet(): MutableList<Pair> {\n        val pairSet = ArrayList<Pair>()\n        for (pair in buckets) {\n            if (pair != null) pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    fun keySet(): MutableList<Int> {\n        val keySet = ArrayList<Int>()\n        for (pair in buckets) {\n            if (pair != null) keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    fun valueSet(): MutableList<String> {\n        val valueSet = ArrayList<String>()\n        for (pair in buckets) {\n            pair?.let { valueSet.add(it.value) }\n        }\n        return valueSet\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val value = kv.value\n            println(\"${key}->${value}\")\n        }\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private val buckets = arrayOfNulls<Pair>(100)\n\n    init {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        for (i in 0..<100) {\n            buckets[i] = null\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair.value\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        val pair = Pair(key, value)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    fun pairSet(): MutableList<Pair> {\n        val pairSet = ArrayList<Pair>()\n        for (pair in buckets) {\n            if (pair != null) pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    fun keySet(): MutableList<Int> {\n        val keySet = ArrayList<Int>()\n        for (pair in buckets) {\n            if (pair != null) keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    fun valueSet(): MutableList<String> {\n        val valueSet = ArrayList<String>()\n        for (pair in buckets) {\n            pair?.let { valueSet.add(it.value) }\n        }\n        return valueSet\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val value = kv.value\n            println(\"${key}->${value}\")\n        }\n    }\n}\n
    array_hash_map.rb
    [class]{Pair}-[func]{}\n\n[class]{ArrayHashMap}-[func]{}\n
    array_hash_map.zig
    // \u952e\u503c\u5bf9\nconst Pair = struct {\n    key: usize = undefined,\n    val: []const u8 = undefined,\n\n   pub fn init(key: usize, val: []const u8) Pair {\n        return Pair {\n            .key = key,\n            .val = val,\n        };\n    }\n};\n\n// \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\nfn ArrayHashMap(comptime T: type) type {\n    return struct {\n        bucket: ?std.ArrayList(?T) = null,\n        mem_allocator: std.mem.Allocator = undefined,\n\n        const Self = @This();\n\n        // \u6784\u9020\u51fd\u6570\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            self.mem_allocator = allocator;\n            // \u521d\u59cb\u5316\u4e00\u4e2a\u957f\u5ea6\u4e3a 100 \u7684\u6876\uff08\u6570\u7ec4\uff09\n            self.bucket = std.ArrayList(?T).init(self.mem_allocator);\n            var i: i32 = 0;\n            while (i < 100) : (i += 1) {\n                try self.bucket.?.append(null);\n            }\n        }\n\n        // \u6790\u6784\u51fd\u6570\n        pub fn deinit(self: *Self) void {\n            if (self.bucket != null) self.bucket.?.deinit();\n        }\n\n        // \u54c8\u5e0c\u51fd\u6570\n        fn hashFunc(key: usize) usize {\n            var index = key % 100;\n            return index;\n        }\n\n        // \u67e5\u8be2\u64cd\u4f5c\n        pub fn get(self: *Self, key: usize) []const u8 {\n            var index = hashFunc(key);\n            var pair = self.bucket.?.items[index];\n            return pair.?.val;\n        }\n\n        // \u6dfb\u52a0\u64cd\u4f5c\n        pub fn put(self: *Self, key: usize, val: []const u8) !void {\n            var pair = Pair.init(key, val);\n            var index = hashFunc(key);\n            self.bucket.?.items[index] = pair;\n        }\n\n        // \u5220\u9664\u64cd\u4f5c\n        pub fn remove(self: *Self, key: usize) !void {\n            var index = hashFunc(key);\n            // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n            self.bucket.?.items[index] = null;\n        }       \n\n        // \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\n        pub fn pairSet(self: *Self) !std.ArrayList(T) {\n            var entry_set = std.ArrayList(T).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try entry_set.append(item.?);\n            }\n            return entry_set;\n        }  \n\n        // \u83b7\u53d6\u6240\u6709\u952e\n        pub fn keySet(self: *Self) !std.ArrayList(usize) {\n            var key_set = std.ArrayList(usize).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try key_set.append(item.?.key);\n            }\n            return key_set;\n        }  \n\n        // \u83b7\u53d6\u6240\u6709\u503c\n        pub fn valueSet(self: *Self) !std.ArrayList([]const u8) {\n            var value_set = std.ArrayList([]const u8).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try value_set.append(item.?.val);\n            }\n            return value_set;\n        }\n\n        // \u6253\u5370\u54c8\u5e0c\u8868\n        pub fn print(self: *Self) !void {\n            var entry_set = try self.pairSet();\n            defer entry_set.deinit();\n            for (entry_set.items) |item| {\n                std.debug.print(\"{} -> {s}\\n\", .{item.key, item.val});\n            }\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_hashing/hash_map/#613","title":"6.1.3 \u00a0 \u54c8\u5e0c\u51b2\u7a81\u4e0e\u6269\u5bb9","text":"

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u54c8\u5e0c\u51fd\u6570\u7684\u4f5c\u7528\u662f\u5c06\u6240\u6709 key \u6784\u6210\u7684\u8f93\u5165\u7a7a\u95f4\u6620\u5c04\u5230\u6570\u7ec4\u6240\u6709\u7d22\u5f15\u6784\u6210\u7684\u8f93\u51fa\u7a7a\u95f4\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

    12836 % 100 = 36\n20336 % 100 = 36\n

    \u5982\u56fe 6-3 \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

    \u56fe 6-3 \u00a0 \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\u56fe 6-4 \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

    \u56fe 6-4 \u00a0 \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\uff1b\u5e76\u4e14\u7531\u4e8e\u54c8\u5e0c\u8868\u5bb9\u91cf capacity \u6539\u53d8\uff0c\u6211\u4eec\u9700\u8981\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u6765\u91cd\u65b0\u8ba1\u7b97\u6240\u6709\u952e\u503c\u5bf9\u7684\u5b58\u50a8\u4f4d\u7f6e\uff0c\u8fd9\u8fdb\u4e00\u6b65\u589e\u52a0\u4e86\u6269\u5bb9\u8fc7\u7a0b\u7684\u8ba1\u7b97\u5f00\u9500\u3002\u4e3a\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

    \u300c\u8d1f\u8f7d\u56e0\u5b50 load factor\u300d\u662f\u54c8\u5e0c\u8868\u7684\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\u7528\u4e8e\u8861\u91cf\u54c8\u5e0c\u51b2\u7a81\u7684\u4e25\u91cd\u7a0b\u5ea6\uff0c\u4e5f\u5e38\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\u6269\u5bb9\u81f3\u539f\u5148\u7684 \\(2\\) \u500d\u3002

    "},{"location":"chapter_hashing/summary/","title":"6.4 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_hashing/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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\u901a\u8fc7\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\u5747\u5300\u5206\u5e03\uff0c\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u3002
    • \u5e38\u89c1\u7684\u54c8\u5e0c\u7b97\u6cd5\u5305\u62ec MD5\u3001SHA-1\u3001SHA-2 \u548c SHA-3 \u7b49\u3002MD5 \u5e38\u7528\u4e8e\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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5728\u4ec0\u4e48\u60c5\u51b5\u4e0b\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\u5f97\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

    Q\uff1a\u4e3a\u4ec0\u4e48\u4e0d\u4f7f\u7528\u54c8\u5e0c\u51fd\u6570 \\(f(x) = x\\) \u5462\uff1f\u8fd9\u6837\u5c31\u4e0d\u4f1a\u6709\u51b2\u7a81\u4e86\u3002

    \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

    Q\uff1a\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\u5b83\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\u5185\u5b58\u672a\u4f7f\u7528\u3002

    \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

    Q\uff1a\u591a\u6b21\u54c8\u5e0c\u6709\u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u7684\u7f3a\u9677\u5417\uff1f\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\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\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u7a7a\u95f4\u53ef\u4ee5\u518d\u6b21\u4f7f\u7528\u3002\u5f53\u5c06\u65b0\u5143\u7d20\u63d2\u5165\u54c8\u5e0c\u8868\uff0c\u5e76\u4e14\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u627e\u5230\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u4f4d\u7f6e\u65f6\uff0c\u8be5\u4f4d\u7f6e\u53ef\u4ee5\u88ab\u65b0\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

    Q\uff1a\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

    Q\uff1a\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\u6a21\uff08\u53d6\u4f59\uff09\uff0c\u8ba9\u8f93\u51fa\u503c\u843d\u5728\u6570\u7ec4\u7d22\u5f15\u8303\u56f4\u5185\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":"\u7b2c 8 \u7ae0 \u00a0 \u5806","text":"

    Abstract

    \u5806\u5c31\u50cf\u662f\u5c71\u5cb3\u5cf0\u5ce6\uff0c\u5c42\u53e0\u8d77\u4f0f\u3001\u5f62\u6001\u5404\u5f02\u3002

    \u5ea7\u5ea7\u5c71\u5cf0\u9ad8\u4f4e\u9519\u843d\uff0c\u800c\u6700\u9ad8\u7684\u5c71\u5cf0\u603b\u662f\u6700\u5148\u6620\u5165\u773c\u5e18\u3002

    "},{"location":"chapter_heap/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 8.1 \u00a0 \u5806
    • 8.2 \u00a0 \u5efa\u5806\u64cd\u4f5c
    • 8.3 \u00a0 Top-k \u95ee\u9898
    • 8.4 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_heap/build_heap/","title":"8.2 \u00a0 \u5efa\u5806\u64cd\u4f5c","text":"

    \u5728\u67d0\u4e9b\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u5e0c\u671b\u4f7f\u7528\u4e00\u4e2a\u5217\u8868\u7684\u6240\u6709\u5143\u7d20\u6765\u6784\u5efa\u4e00\u4e2a\u5806\uff0c\u8fd9\u4e2a\u8fc7\u7a0b\u88ab\u79f0\u4e3a\u201c\u5efa\u5806\u64cd\u4f5c\u201d\u3002

    "},{"location":"chapter_heap/build_heap/#821","title":"8.2.1 \u00a0 \u501f\u52a9\u5165\u5806\u64cd\u4f5c\u5b9e\u73b0","text":"

    \u6211\u4eec\u9996\u5148\u521b\u5efa\u4e00\u4e2a\u7a7a\u5806\uff0c\u7136\u540e\u904d\u5386\u5217\u8868\uff0c\u4f9d\u6b21\u5bf9\u6bcf\u4e2a\u5143\u7d20\u6267\u884c\u201c\u5165\u5806\u64cd\u4f5c\u201d\uff0c\u5373\u5148\u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u5806\u7684\u5c3e\u90e8\uff0c\u518d\u5bf9\u8be5\u5143\u7d20\u6267\u884c\u201c\u4ece\u5e95\u81f3\u9876\u201d\u5806\u5316\u3002

    \u6bcf\u5f53\u4e00\u4e2a\u5143\u7d20\u5165\u5806\uff0c\u5806\u7684\u957f\u5ea6\u5c31\u52a0\u4e00\u3002\u7531\u4e8e\u8282\u70b9\u662f\u4ece\u9876\u5230\u5e95\u4f9d\u6b21\u88ab\u6dfb\u52a0\u8fdb\u4e8c\u53c9\u6811\u7684\uff0c\u56e0\u6b64\u5806\u662f\u201c\u81ea\u4e0a\u800c\u4e0b\u201d\u6784\u5efa\u7684\u3002

    \u8bbe\u5143\u7d20\u6570\u91cf\u4e3a \\(n\\) \uff0c\u6bcf\u4e2a\u5143\u7d20\u7684\u5165\u5806\u64cd\u4f5c\u4f7f\u7528 \\(O(\\log{n})\\) \u65f6\u95f4\uff0c\u56e0\u6b64\u8be5\u5efa\u5806\u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    "},{"location":"chapter_heap/build_heap/#822","title":"8.2.2 \u00a0 \u901a\u8fc7\u904d\u5386\u5806\u5316\u5b9e\u73b0","text":"

    \u5b9e\u9645\u4e0a\uff0c\u6211\u4eec\u53ef\u4ee5\u5b9e\u73b0\u4e00\u79cd\u66f4\u4e3a\u9ad8\u6548\u7684\u5efa\u5806\u65b9\u6cd5\uff0c\u5171\u5206\u4e3a\u4e24\u6b65\u3002

    1. \u5c06\u5217\u8868\u6240\u6709\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u5730\u6dfb\u52a0\u5230\u5806\u4e2d\uff0c\u6b64\u65f6\u5806\u7684\u6027\u8d28\u5c1a\u672a\u5f97\u5230\u6ee1\u8db3\u3002
    2. \u5012\u5e8f\u904d\u5386\u5806\uff08\u5c42\u5e8f\u904d\u5386\u7684\u5012\u5e8f\uff09\uff0c\u4f9d\u6b21\u5bf9\u6bcf\u4e2a\u975e\u53f6\u8282\u70b9\u6267\u884c\u201c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u201d\u3002

    \u6bcf\u5f53\u5806\u5316\u4e00\u4e2a\u8282\u70b9\u540e\uff0c\u4ee5\u8be5\u8282\u70b9\u4e3a\u6839\u8282\u70b9\u7684\u5b50\u6811\u5c31\u5f62\u6210\u4e00\u4e2a\u5408\u6cd5\u7684\u5b50\u5806\u3002\u800c\u7531\u4e8e\u662f\u5012\u5e8f\u904d\u5386\uff0c\u56e0\u6b64\u5806\u662f\u201c\u81ea\u4e0b\u800c\u4e0a\u201d\u6784\u5efa\u7684\u3002

    \u4e4b\u6240\u4ee5\u9009\u62e9\u5012\u5e8f\u904d\u5386\uff0c\u662f\u56e0\u4e3a\u8fd9\u6837\u80fd\u591f\u4fdd\u8bc1\u5f53\u524d\u8282\u70b9\u4e4b\u4e0b\u7684\u5b50\u6811\u5df2\u7ecf\u662f\u5408\u6cd5\u7684\u5b50\u5806\uff0c\u8fd9\u6837\u5806\u5316\u5f53\u524d\u8282\u70b9\u624d\u662f\u6709\u6548\u7684\u3002

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u7531\u4e8e\u53f6\u8282\u70b9\u6ca1\u6709\u5b50\u8282\u70b9\uff0c\u56e0\u6b64\u5b83\u4eec\u5929\u7136\u5c31\u662f\u5408\u6cd5\u7684\u5b50\u5806\uff0c\u65e0\u987b\u5806\u5316\u3002\u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u6700\u540e\u4e00\u4e2a\u975e\u53f6\u8282\u70b9\u662f\u6700\u540e\u4e00\u4e2a\u8282\u70b9\u7684\u7236\u8282\u70b9\uff0c\u6211\u4eec\u4ece\u5b83\u5f00\u59cb\u5012\u5e8f\u904d\u5386\u5e76\u6267\u884c\u5806\u5316\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    self.max_heap = nums\n    # \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\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\n    maxHeap = nums;\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (int i = parent(size() - 1); i >= 0; i--) {\n        siftDown(i);\n    }\n}\n
    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\n    maxHeap = new ArrayList<>(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (int i = parent(size() - 1); i >= 0; i--) {\n        siftDown(i);\n    }\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\n    maxHeap = new List<int>(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i >= 0; i--) {\n        SiftDown(i);\n    }\n}\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\n    h := &maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i >= 0; i-- {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        h.siftDown(i)\n    }\n    return h\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\n    maxHeap = nums\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\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\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (let i = this.#parent(this.size() - 1); i >= 0; i--) {\n        this.#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\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (let i = this.parent(this.size() - 1); i >= 0; i--) {\n        this.siftDown(i);\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\n  for (int i = _parent(size() - 1); i >= 0; i--) {\n    siftDown(i);\n  }\n}\n
    my_heap.rs
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nfn new(nums: Vec<i32>) -> Self {\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    let mut heap = MaxHeap { max_heap: nums };\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\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\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap->size = size;\n    memcpy(maxHeap->data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i >= 0; i--) {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n
    my_heap.kt
    /* \u5927\u9876\u5806 */\nclass MaxHeap(nums: List<Int>?) {\n    // \u4f7f\u7528\u5217\u8868\u800c\u975e\u6570\u7ec4\uff0c\u8fd9\u6837\u65e0\u987b\u8003\u8651\u6269\u5bb9\u95ee\u9898\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    private val maxHeap = ArrayList(nums!!)\n\n    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\n    init {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u4ea4\u6362\u5143\u7d20 */\n    private fun swap(i: Int, j: Int) {\n        maxHeap[i] = maxHeap[j].also { maxHeap[j] = maxHeap[i] }\n    }\n\n    /* \u83b7\u53d6\u5806\u5927\u5c0f */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n        return size() == 0\n    }\n\n    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* \u5143\u7d20\u5165\u5806 */\n    fun push(value: Int) {\n        // \u6dfb\u52a0\u8282\u70b9\n        maxHeap.add(value)\n        // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n        siftUp(size() - 1)\n    }\n\n    /* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\n    private fun siftUp(it: Int) {\n        // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n        var i = it\n        while (true) {\n            // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n            val p = parent(i)\n            // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n            if (p < 0 || maxHeap[i] <= maxHeap[p]) break\n            // \u4ea4\u6362\u4e24\u8282\u70b9\n            swap(i, p)\n            // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n            i = p\n        }\n    }\n\n    /* \u5143\u7d20\u51fa\u5806 */\n    fun pop(): Int {\n        // \u5224\u7a7a\u5904\u7406\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        swap(0, size() - 1)\n        // \u5220\u9664\u8282\u70b9\n        val value = maxHeap.removeAt(size() - 1)\n        // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n        siftDown(0)\n        // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n        return value\n    }\n\n    /* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\n    private fun siftDown(it: Int) {\n        // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n        var i = it\n        while (true) {\n            // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l\n            if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r\n            // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n            if (ma == i) break\n            // \u4ea4\u6362\u4e24\u8282\u70b9\n            swap(i, ma)\n            // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n            i = ma\n        }\n    }\n\n    /* \u6253\u5370\u5806\uff08\u4e8c\u53c9\u6811\uff09 */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -> b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{__init__}\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 {\n    if (self.max_heap != null) return;\n    self.max_heap = std.ArrayList(T).init(allocator);\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    try self.max_heap.?.appendSlice(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    var i: usize = parent(self.size() - 1) + 1;\n    while (i > 0) : (i -= 1) {\n        try self.siftDown(i - 1);\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_heap/build_heap/#823","title":"8.2.3 \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    \u4e0b\u9762\uff0c\u6211\u4eec\u6765\u5c1d\u8bd5\u63a8\u7b97\u7b2c\u4e8c\u79cd\u5efa\u5806\u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    • \u5047\u8bbe\u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(n\\) \uff0c\u5219\u53f6\u8282\u70b9\u6570\u91cf\u4e3a \\((n + 1) / 2\\) \uff0c\u5176\u4e2d \\(/\\) \u4e3a\u5411\u4e0b\u6574\u9664\u3002\u56e0\u6b64\u9700\u8981\u5806\u5316\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\((n - 1) / 2\\) \u3002
    • \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 \\(\\log n\\) \u3002

    \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\u4f46\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\u6027\u8d28\u3002

    \u63a5\u4e0b\u6765\u6211\u4eec\u6765\u8fdb\u884c\u66f4\u4e3a\u51c6\u786e\u7684\u8ba1\u7b97\u3002\u4e3a\u4e86\u964d\u4f4e\u8ba1\u7b97\u96be\u5ea6\uff0c\u5047\u8bbe\u7ed9\u5b9a\u4e00\u4e2a\u8282\u70b9\u6570\u91cf\u4e3a \\(n\\) \u3001\u9ad8\u5ea6\u4e3a \\(h\\) \u7684\u201c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u201d\uff0c\u8be5\u5047\u8bbe\u4e0d\u4f1a\u5f71\u54cd\u8ba1\u7b97\u7ed3\u679c\u7684\u6b63\u786e\u6027\u3002

    \u56fe 8-5 \u00a0 \u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u5404\u5c42\u8282\u70b9\u6570\u91cf

    \u5982\u56fe 8-5 \u6240\u793a\uff0c\u8282\u70b9\u201c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u201d\u7684\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\u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u5bf9\u5404\u5c42\u7684\u201c\u8282\u70b9\u6570\u91cf \\(\\times\\) \u8282\u70b9\u9ad8\u5ea6\u201d\u6c42\u548c\uff0c\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) + \\dots + 2^{(h-1)}\\times1 \\]

    \u5316\u7b80\u4e0a\u5f0f\u9700\u8981\u501f\u52a9\u4e2d\u5b66\u7684\u6570\u5217\u77e5\u8bc6\uff0c\u5148\u5c06 \\(T(h)\\) \u4e58\u4ee5 \\(2\\) \uff0c\u5f97\u5230\uff1a

    \\[ \\begin{aligned} T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\]

    \u4f7f\u7528\u9519\u4f4d\u76f8\u51cf\u6cd5\uff0c\u7528\u4e0b\u5f0f \\(2 T(h)\\) \u51cf\u53bb\u4e0a\u5f0f \\(T(h)\\) \uff0c\u53ef\u5f97\uff1a

    \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 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\uff1a

    \\[ \\begin{aligned} T(h) & = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline & = 2^{h+1} - h - 2 \\newline & = O(2^h) \\end{aligned} \\]

    \u8fdb\u4e00\u6b65\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\u4e3b\u8981\u53ef\u5206\u4e3a\u4e24\u79cd\u7c7b\u578b\uff0c\u5982\u56fe 8-1 \u6240\u793a\u3002

    • \u300c\u5c0f\u9876\u5806 min heap\u300d\uff1a\u4efb\u610f\u8282\u70b9\u7684\u503c \\(\\leq\\) \u5176\u5b50\u8282\u70b9\u7684\u503c\u3002
    • \u300c\u5927\u9876\u5806 max heap\u300d\uff1a\u4efb\u610f\u8282\u70b9\u7684\u503c \\(\\geq\\) \u5176\u5b50\u8282\u70b9\u7684\u503c\u3002

    \u56fe 8-1 \u00a0 \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\u3002

    • \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\u201c\u5806\u9876\u201d\uff0c\u5c06\u5e95\u5c42\u6700\u9760\u53f3\u7684\u8282\u70b9\u79f0\u4e3a\u201c\u5806\u5e95\u201d\u3002
    • \u5bf9\u4e8e\u5927\u9876\u5806\uff08\u5c0f\u9876\u5806\uff09\uff0c\u5806\u9876\u5143\u7d20\uff08\u6839\u8282\u70b9\uff09\u7684\u503c\u662f\u6700\u5927\uff08\u6700\u5c0f\uff09\u7684\u3002
    "},{"location":"chapter_heap/heap/#811","title":"8.1.1 \u00a0 \u5806\u7684\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\u7684\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\u4e8e\u5b9e\u73b0\u4f18\u5148\u961f\u5217\uff0c\u5927\u9876\u5806\u76f8\u5f53\u4e8e\u5143\u7d20\u6309\u4ece\u5927\u5230\u5c0f\u7684\u987a\u5e8f\u51fa\u961f\u7684\u4f18\u5148\u961f\u5217\u3002\u4ece\u4f7f\u7528\u89d2\u5ea6\u6765\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u201c\u4f18\u5148\u961f\u5217\u201d\u548c\u201c\u5806\u201d\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\u79f0\u4f5c\u201c\u5806\u201d\u3002

    \u5806\u7684\u5e38\u7528\u64cd\u4f5c\u89c1\u8868 8-1 \uff0c\u65b9\u6cd5\u540d\u9700\u8981\u6839\u636e\u7f16\u7a0b\u8bed\u8a00\u6765\u786e\u5b9a\u3002

    \u8868 8-1 \u00a0 \u5806\u7684\u64cd\u4f5c\u6548\u7387

    \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\u5bf9\u4e8e\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

    \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\u8bbe\u7f6e\u4e00\u4e2a flag \u6216\u4fee\u6539 Comparator \u5b9e\u73b0\u201c\u5c0f\u9876\u5806\u201d\u4e0e\u201c\u5927\u9876\u5806\u201d\u4e4b\u95f4\u7684\u8f6c\u6362\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig heap.py
    # \u521d\u59cb\u5316\u5c0f\u9876\u5806\nmin_heap, flag = [], 1\n# \u521d\u59cb\u5316\u5927\u9876\u5806\nmax_heap, flag = [], -1\n\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\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\n# \u83b7\u53d6\u5806\u9876\u5143\u7d20\npeek: int = flag * max_heap[0] # 5\n\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\n# \u83b7\u53d6\u5806\u5927\u5c0f\nsize: int = len(max_heap)\n\n# \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = not max_heap\n\n# \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\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\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.top(); // 5\n\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\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.empty();\n\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.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\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.peek(); // 5\n\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.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));\n
    heap.cs
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nPriorityQueue<int, int> minHeap = new();\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(Comparer<int>.Create((x, y) => y - x));\n\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\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.Peek();//5\n\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\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.Count;\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.Count == 0;\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<int, int>([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\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\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\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\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\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\n    return (*h)[i].(int) > (*h)[j].(int)\n}\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\n// Top \u83b7\u53d6\u5806\u9876\u5143\u7d20\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* \u521d\u59cb\u5316\u5806 */\n    // \u521d\u59cb\u5316\u5927\u9876\u5806\n    maxHeap := &intHeap{}\n    heap.Init(maxHeap)\n    /* \u5143\u7d20\u5165\u5806 */\n    // \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u6dfb\u52a0\u5143\u7d20\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\n    top := maxHeap.Top()\n    fmt.Printf(\"\u5806\u9876\u5143\u7d20\u4e3a %d\\n\", top)\n\n    /* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n    // \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u79fb\u9664\u5143\u7d20\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* \u83b7\u53d6\u5806\u5927\u5c0f */\n    size := len(*maxHeap)\n    fmt.Printf(\"\u5806\u5143\u7d20\u6570\u91cf\u4e3a %d\\n\", size)\n\n    /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"\u5806\u662f\u5426\u4e3a\u7a7a %t\\n\", isEmpty)\n}\n
    heap.swift
    /* \u521d\u59cb\u5316\u5806 */\n// Swift \u7684 Heap \u7c7b\u578b\u540c\u65f6\u652f\u6301\u6700\u5927\u5806\u548c\u6700\u5c0f\u5806\uff0c\u4e14\u9700\u8981\u5f15\u5165 swift-collections\nvar heap = Heap<Int>()\n\n/* \u5143\u7d20\u5165\u5806 */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nvar peek = heap.max()!\n\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nlet size = heap.count\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = heap.isEmpty\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n
    heap.js
    // JavaScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.ts
    // TypeScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.dart
    // Dart \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.rs
    use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nlet mut min_heap = BinaryHeap::<Reverse<i32>>::new();\n// \u521d\u59cb\u5316\u5927\u9876\u5806\nlet mut max_heap = BinaryHeap::new();\n\n/* \u5143\u7d20\u5165\u5806 */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nlet size = max_heap.len();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = max_heap.is_empty();\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n
    heap.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.kt
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nvar minHeap = PriorityQueue<Int>()\n// \u521d\u59cb\u5316\u5927\u9876\u5806\uff08\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\u4fee\u6539 Comparator \u5373\u53ef\uff09\nval maxHeap = PriorityQueue { a: Int, b: Int -> b - a }\n\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nvar peek = maxHeap.peek() // 5\n\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.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nval size = maxHeap.size\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = maxHeap.isEmpty()\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n
    heap.rb
    \n
    heap.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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":"1. \u00a0 \u5806\u7684\u5b58\u50a8\u4e0e\u8868\u793a","text":"

    \u201c\u4e8c\u53c9\u6811\u201d\u7ae0\u8282\u8bb2\u8fc7\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\u56e0\u6b64\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

    \u5982\u56fe 8-2 \u6240\u793a\uff0c\u7ed9\u5b9a\u7d22\u5f15 \\(i\\) \uff0c\u5176\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\u4e3a \\(2i + 1\\) \uff0c\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\u4e3a \\(2i + 2\\) \uff0c\u7236\u8282\u70b9\u7684\u7d22\u5f15\u4e3a \\((i - 1) / 2\\)\uff08\u5411\u4e0b\u6574\u9664\uff09\u3002\u5f53\u7d22\u5f15\u8d8a\u754c\u65f6\uff0c\u8868\u793a\u7a7a\u8282\u70b9\u6216\u8282\u70b9\u4e0d\u5b58\u5728\u3002

    \u56fe 8-2 \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def left(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return (i - 1) // 2  # \u5411\u4e0b\u6574\u9664\n
    my_heap.cpp
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.java
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.cs
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint Parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.go
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) parent(i int) int {\n    // \u5411\u4e0b\u6574\u9664\n    return (i - 1) / 2\n}\n
    my_heap.swift
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc left(i: Int) -> Int {\n    2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc right(i: Int) -> Int {\n    2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc parent(i: Int) -> Int {\n    (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.js
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.ts
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.dart
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.rs
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfn left(i: usize) -> usize {\n    2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfn right(i: usize) -> usize {\n    2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfn parent(i: usize) -> usize {\n    (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.c
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2;\n}\n
    my_heap.kt
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{left}\n\n[class]{MaxHeap}-[func]{right}\n\n[class]{MaxHeap}-[func]{parent}\n
    my_heap.zig
    // \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\nfn left(i: usize) usize {\n    return 2 * i + 1;\n}\n\n// \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\nfn right(i: usize) usize {\n    return 2 * i + 2;\n}\n\n// \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15\nfn parent(i: usize) usize {\n    // return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n    return @divFloor(i - 1, 2);\n}\n
    "},{"location":"chapter_heap/heap/#2","title":"2. \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def peek(self) -> int:\n    \"\"\"\u8bbf\u95ee\u5806\u9876\u5143\u7d20\"\"\"\n    return self.max_heap[0]\n
    my_heap.cpp
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n    return maxHeap[0];\n}\n
    my_heap.java
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n    return maxHeap.get(0);\n}\n
    my_heap.cs
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint Peek() {\n    return maxHeap[0];\n}\n
    my_heap.go
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n
    my_heap.swift
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc peek() -> Int {\n    maxHeap[0]\n}\n
    my_heap.js
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek() {\n    return this.#maxHeap[0];\n}\n
    my_heap.ts
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek(): number {\n    return this.maxHeap[0];\n}\n
    my_heap.dart
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n  return _maxHeap[0];\n}\n
    my_heap.rs
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfn peek(&self) -> Option<i32> {\n    self.max_heap.first().copied()\n}\n
    my_heap.c
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap->data[0];\n}\n
    my_heap.kt
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfun peek(): Int {\n    return maxHeap[0]\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{peek}\n
    my_heap.zig
    // \u8bbf\u95ee\u5806\u9876\u5143\u7d20\nfn peek(self: *Self) T {\n    return self.max_heap.?.items[0];\n}  \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_heap/heap/#3","title":"3. \u00a0 \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\uff0c\u56e0\u6b64\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\u5982\u56fe 8-3 \u6240\u793a\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\u987b\u4ea4\u6362\u7684\u8282\u70b9\u65f6\u7ed3\u675f\u3002

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

    \u56fe 8-3 \u00a0 \u5143\u7d20\u5165\u5806\u6b65\u9aa4

    \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def push(self, val: int):\n    \"\"\"\u5143\u7d20\u5165\u5806\"\"\"\n    # \u6dfb\u52a0\u8282\u70b9\n    self.max_heap.append(val)\n    # \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\"\"\"\n    while True:\n        # \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        p = self.parent(i)\n        # \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 or self.max_heap[i] <= self.max_heap[p]:\n            break\n        # \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, p)\n        # \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n
    my_heap.cpp
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.push_back(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p])\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap[i], maxHeap[p]);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.java
    /* \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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.cs
    /* \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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid SiftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = Parent(i);\n        // \u82e5\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p])\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        Swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.go
    /* \u5143\u7d20\u5165\u5806 */\nfunc (h *maxHeap) push(val any) {\n    // \u6dfb\u52a0\u8282\u70b9\n    h.data = append(h.data, val)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    h.siftUp(len(h.data) - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        p := h.parent(i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 || h.data[i].(int) <= h.data[p].(int) {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        h.swap(i, p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.swift
    /* \u5143\u7d20\u5165\u5806 */\nfunc push(val: Int) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.append(val)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(i: size() - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        let p = parent(i: i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 || maxHeap[i] <= maxHeap[p] {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i: i, j: p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.js
    /* \u5143\u7d20\u5165\u5806 */\npush(val) {\n    // \u6dfb\u52a0\u8282\u70b9\n    this.#maxHeap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    this.#siftUp(this.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\n#siftUp(i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        const p = this.#parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.#swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.ts
    /* \u5143\u7d20\u5165\u5806 */\npush(val: number): void {\n    // \u6dfb\u52a0\u8282\u70b9\n    this.maxHeap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    this.siftUp(this.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nsiftUp(i: number): void {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        const p = this.parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = 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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n  while (true) {\n    // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n    int p = _parent(i);\n    // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n    if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {\n      break;\n    }\n    // \u4ea4\u6362\u4e24\u8282\u70b9\n    _swap(i, p);\n    // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n    i = p;\n  }\n}\n
    my_heap.rs
    /* \u5143\u7d20\u5165\u5806 */\nfn push(&mut self, val: i32) {\n    // \u6dfb\u52a0\u8282\u70b9\n    self.max_heap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    self.sift_up(self.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfn sift_up(&mut self, mut i: usize) {\n    loop {\n        // \u8282\u70b9 i \u5df2\u7ecf\u662f\u5806\u9876\u8282\u70b9\u4e86\uff0c\u7ed3\u675f\u5806\u5316\n        if i == 0 {\n            break;\n        }\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        let p = Self::parent(i);\n        // \u5f53\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if self.max_heap[i] <= self.max_heap[p] {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.c
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(MaxHeap *maxHeap, int val) {\n    // \u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u4e0d\u5e94\u8be5\u6dfb\u52a0\u8fd9\u4e48\u591a\u8282\u70b9\n    if (maxHeap->size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap->data[maxHeap->size] = val;\n    maxHeap->size++;\n\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(maxHeap, maxHeap->size - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(maxHeap, i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap->data[i] <= maxHeap->data[p]) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap, i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.kt
    /* \u5143\u7d20\u5165\u5806 */\nfun push(value: Int) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.add(value)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(size() - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfun siftUp(it: Int) {\n    // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n    var i = it\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        val p = parent(i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p]) break\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{push}\n\n[class]{MaxHeap}-[func]{sift_up}\n
    my_heap.zig
    // \u5143\u7d20\u5165\u5806\nfn push(self: *Self, val: T) !void {\n    // \u6dfb\u52a0\u8282\u70b9\n    try self.max_heap.?.append(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    try self.siftUp(self.size() - 1);\n}  \n\n// \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\nfn siftUp(self: *Self, i_: usize) !void {\n    var i = i_;\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        var p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        try self.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_heap/heap/#4","title":"4. \u00a0 \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\u8fdb\u884c\u4fee\u590d\u53d8\u5f97\u56f0\u96be\u3002\u4e3a\u4e86\u5c3d\u91cf\u51cf\u5c11\u5143\u7d20\u7d22\u5f15\u7684\u53d8\u52a8\uff0c\u6211\u4eec\u91c7\u7528\u4ee5\u4e0b\u64cd\u4f5c\u6b65\u9aa4\u3002

    1. \u4ea4\u6362\u5806\u9876\u5143\u7d20\u4e0e\u5806\u5e95\u5143\u7d20\uff08\u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff09\u3002
    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\u56e0\u6b64\u5b9e\u9645\u4e0a\u5220\u9664\u7684\u662f\u539f\u6765\u7684\u5806\u9876\u5143\u7d20\uff09\u3002
    3. \u4ece\u6839\u8282\u70b9\u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u6267\u884c\u5806\u5316\u3002

    \u5982\u56fe 8-4 \u6240\u793a\uff0c\u201c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u201d\u7684\u64cd\u4f5c\u65b9\u5411\u4e0e\u201c\u4ece\u5e95\u81f3\u9876\u5806\u5316\u201d\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\u3002\u7136\u540e\u5faa\u73af\u6267\u884c\u6b64\u64cd\u4f5c\uff0c\u76f4\u5230\u8d8a\u8fc7\u53f6\u8282\u70b9\u6216\u9047\u5230\u65e0\u987b\u4ea4\u6362\u7684\u8282\u70b9\u65f6\u7ed3\u675f\u3002

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

    \u56fe 8-4 \u00a0 \u5806\u9876\u5143\u7d20\u51fa\u5806\u6b65\u9aa4

    \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def pop(self) -> int:\n    \"\"\"\u5143\u7d20\u51fa\u5806\"\"\"\n    # \u5224\u7a7a\u5904\u7406\n    if self.is_empty():\n        raise IndexError(\"\u5806\u4e3a\u7a7a\")\n    # \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    self.swap(0, self.size() - 1)\n    # \u5220\u9664\u8282\u70b9\n    val = self.max_heap.pop()\n    # \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    self.sift_down(0)\n    # \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\"\"\"\n    while True:\n        # \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l < self.size() and self.max_heap[l] > self.max_heap[ma]:\n            ma = l\n        if r < self.size() and self.max_heap[r] > self.max_heap[ma]:\n            ma = r\n        # \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i:\n            break\n        # \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, ma)\n        # \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n
    my_heap.cpp
    /* \u5143\u7d20\u51fa\u5806 */\nvoid pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty()) {\n        throw out_of_range(\"\u5806\u4e3a\u7a7a\");\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // \u5220\u9664\u8282\u70b9\n    maxHeap.pop_back();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = left(i), r = right(i), ma = i;\n        if (l < size() && maxHeap[l] > maxHeap[ma])\n            ma = l;\n        if (r < size() && maxHeap[r] > maxHeap[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.java
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(0, size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap.remove(size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = left(i), r = right(i), ma = i;\n        if (l < size() && maxHeap.get(l) > maxHeap.get(ma))\n            ma = l;\n        if (r < size() && maxHeap.get(r) > maxHeap.get(ma))\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.cs
    /* \u5143\u7d20\u51fa\u5806 */\nint Pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    Swap(0, Size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    SiftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid SiftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = Left(i), r = Right(i), ma = i;\n        if (l < Size() && maxHeap[l] > maxHeap[ma])\n            ma = l;\n        if (r < Size() && maxHeap[r] > maxHeap[ma])\n            ma = r;\n        // \u82e5\u201c\u8282\u70b9 i \u6700\u5927\u201d\u6216\u201c\u8d8a\u8fc7\u53f6\u8282\u70b9\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\n        if (ma == i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        Swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.go
    /* \u5143\u7d20\u51fa\u5806 */\nfunc (h *maxHeap) pop() any {\n    // \u5224\u7a7a\u5904\u7406\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    h.swap(0, h.size()-1)\n    // \u5220\u9664\u8282\u70b9\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    h.siftDown(0)\n\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\n        l, r, max := h.left(i), h.right(i), i\n        if l < h.size() && h.data[l].(int) > h.data[max].(int) {\n            max = l\n        }\n        if r < h.size() && h.data[r].(int) > h.data[max].(int) {\n            max = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if max == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        h.swap(i, max)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = max\n    }\n}\n
    my_heap.swift
    /* \u5143\u7d20\u51fa\u5806 */\nfunc pop() -> Int {\n    // \u5224\u7a7a\u5904\u7406\n    if isEmpty() {\n        fatalError(\"\u5806\u4e3a\u7a7a\")\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(i: 0, j: size() - 1)\n    // \u5220\u9664\u8282\u70b9\n    let val = maxHeap.remove(at: size() - 1)\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(i: 0)\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l < size(), maxHeap[l] > maxHeap[ma] {\n            ma = l\n        }\n        if r < size(), maxHeap[r] > maxHeap[ma] {\n            ma = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i: i, j: ma)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\n}\n
    my_heap.js
    /* \u5143\u7d20\u51fa\u5806 */\npop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (this.isEmpty()) throw new Error('\u5806\u4e3a\u7a7a');\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    this.#swap(0, this.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    const val = this.#maxHeap.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    this.#siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\n#siftDown(i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.#swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.ts
    /* \u5143\u7d20\u51fa\u5806 */\npop(): number {\n    // \u5224\u7a7a\u5904\u7406\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    this.swap(0, this.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    const val = this.maxHeap.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    this.siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nsiftDown(i: number): void {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.dart
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n  // \u5224\u7a7a\u5904\u7406\n  if (isEmpty()) throw Exception('\u5806\u4e3a\u7a7a');\n  // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n  _swap(0, size() - 1);\n  // \u5220\u9664\u8282\u70b9\n  int val = _maxHeap.removeLast();\n  // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n  siftDown(0);\n  // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n  return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n  while (true) {\n    // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;\n    if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;\n    // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n    if (ma == i) break;\n    // \u4ea4\u6362\u4e24\u8282\u70b9\n    _swap(i, ma);\n    // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n    i = ma;\n  }\n}\n
    my_heap.rs
    /* \u5143\u7d20\u51fa\u5806 */\nfn pop(&mut self) -> i32 {\n    // \u5224\u7a7a\u5904\u7406\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    self.swap(0, self.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    let val = self.max_heap.remove(self.size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    self.sift_down(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfn sift_down(&mut self, mut i: usize) {\n    loop {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l < self.size() && self.max_heap[l] > self.max_heap[ma] {\n            ma = l;\n        }\n        if r < self.size() && self.max_heap[r] > self.max_heap[ma] {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.c
    /* \u5143\u7d20\u51fa\u5806 */\nint pop(MaxHeap *maxHeap) {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap->data[maxHeap->size - 1];\n    maxHeap->size--;\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(maxHeap, 0);\n\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l < size(maxHeap) && maxHeap->data[l] > maxHeap->data[max]) {\n            max = l;\n        }\n        if (r < size(maxHeap) && maxHeap->data[r] > maxHeap->data[max]) {\n            max = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (max == i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap, i, max);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = max;\n    }\n}\n
    my_heap.kt
    /* \u5143\u7d20\u51fa\u5806 */\nfun pop(): Int {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(0, size() - 1)\n    // \u5220\u9664\u8282\u70b9\n    val value = maxHeap.removeAt(size() - 1)\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0)\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return value\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfun siftDown(it: Int) {\n    // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n    var i = it\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l\n        if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) break\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, ma)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{pop}\n\n[class]{MaxHeap}-[func]{sift_down}\n
    my_heap.zig
    // \u5143\u7d20\u51fa\u5806\nfn pop(self: *Self) !T {\n    // \u5224\u65ad\u5904\u7406\n    if (self.isEmpty()) unreachable;\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    try self.swap(0, self.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    var val = self.max_heap.?.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    try self.siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n} \n\n// \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\nfn siftDown(self: *Self, i_: usize) !void {\n    var i = i_;\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        var l = left(i);\n        var r = right(i);\n        var ma = i;\n        if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        try self.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_heap/heap/#813","title":"8.1.3 \u00a0 \u5806\u7684\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\u201c\u5806\u6392\u5e8f\u201d\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":""},{"location":"chapter_heap/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u201c\u5806\u201d\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\u6f0f\u3002\u76f8\u8f83\u4e8e\u6808\u5185\u5b58\uff0c\u5806\u5185\u5b58\u7684\u7ba1\u7406\u548c\u4f7f\u7528\u9700\u8981\u66f4\u8c28\u614e\uff0c\u4f7f\u7528\u4e0d\u5f53\u53ef\u80fd\u4f1a\u5bfc\u81f4\u5185\u5b58\u6cc4\u6f0f\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\\) \u7684\u65e0\u5e8f\u6570\u7ec4 nums \uff0c\u8bf7\u8fd4\u56de\u6570\u7ec4\u4e2d\u6700\u5927\u7684 \\(k\\) \u4e2a\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\u56fe 8-6 \u6240\u793a\u7684 \\(k\\) \u8f6e\u904d\u5386\uff0c\u5206\u522b\u5728\u6bcf\u8f6e\u4e2d\u63d0\u53d6\u7b2c \\(1\\)\u3001\\(2\\)\u3001\\(\\dots\\)\u3001\\(k\\) \u5927\u7684\u5143\u7d20\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nk)\\) \u3002

    \u6b64\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

    \u56fe 8-6 \u00a0 \u904d\u5386\u5bfb\u627e\u6700\u5927\u7684 k \u4e2a\u5143\u7d20

    Tip

    \u5f53 \\(k = n\\) \u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u5230\u5b8c\u6574\u7684\u6709\u5e8f\u5e8f\u5217\uff0c\u6b64\u65f6\u7b49\u4ef7\u4e8e\u201c\u9009\u62e9\u6392\u5e8f\u201d\u7b97\u6cd5\u3002

    "},{"location":"chapter_heap/top_k/#832","title":"8.3.2 \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u6392\u5e8f","text":"

    \u5982\u56fe 8-7 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5148\u5bf9\u6570\u7ec4 nums \u8fdb\u884c\u6392\u5e8f\uff0c\u518d\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\u627e\u51fa\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\u5373\u53ef\uff0c\u800c\u4e0d\u9700\u8981\u6392\u5e8f\u5176\u4ed6\u5143\u7d20\u3002

    \u56fe 8-7 \u00a0 \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\u56fe 8-8 \u6240\u793a\u3002

    1. \u521d\u59cb\u5316\u4e00\u4e2a\u5c0f\u9876\u5806\uff0c\u5176\u5806\u9876\u5143\u7d20\u6700\u5c0f\u3002
    2. \u5148\u5c06\u6570\u7ec4\u7684\u524d \\(k\\) \u4e2a\u5143\u7d20\u4f9d\u6b21\u5165\u5806\u3002
    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\u3002
    4. \u904d\u5386\u5b8c\u6210\u540e\uff0c\u5806\u4e2d\u4fdd\u5b58\u7684\u5c31\u662f\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\u3002
    <1><2><3><4><5><6><7><8><9>

    \u56fe 8-8 \u00a0 \u57fa\u4e8e\u5806\u5bfb\u627e\u6700\u5927\u7684 k \u4e2a\u5143\u7d20

    \u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    # \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    heap = []\n    # \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for 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\n        if nums[i] > heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\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) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    priority_queue<int, vector<int>, greater<int>> heap;\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.push(nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n
    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) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    Queue<Integer> heap = new PriorityQueue<Integer>();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.offer(nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n
    top_k.cs
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nPriorityQueue<int, int> TopKHeap(int[] nums, int k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    PriorityQueue<int, int> heap = new();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n
    top_k.go
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    h := &minHeap{}\n    heap.Init(h)\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for i := 0; i < k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for i := k; i < len(nums); 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\n        if nums[i] > h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\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    // \u521d\u59cb\u5316\u4e00\u4e2a\u5c0f\u9876\u5806\uff0c\u5e76\u5c06\u524d k \u4e2a\u5143\u7d20\u5efa\u5806\n    var heap = Heap(nums.prefix(k))\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for i in nums.indices.dropFirst(k) {\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\n        if nums[i] > heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n
    top_k.js
    /* \u5143\u7d20\u5165\u5806 */\nfunction pushMinHeap(maxHeap, val) {\n    // \u5143\u7d20\u53d6\u53cd\n    maxHeap.push(-val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nfunction popMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.pop();\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunction peekMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.peek();\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nfunction getMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return maxHeap.getMaxHeap().map((num) => -num);\n}\n\n/* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunction topKHeap(nums, k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    const maxHeap = new MaxHeap([]);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (let i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (let 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // \u8fd4\u56de\u5806\u4e2d\u5143\u7d20\n    return getMinHeap(maxHeap);\n}\n
    top_k.ts
    /* \u5143\u7d20\u5165\u5806 */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // \u5143\u7d20\u53d6\u53cd\n    maxHeap.push(-val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.pop();\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.peek();\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // \u5143\u7d20\u53d6\u53cd\n    return maxHeap.getMaxHeap().map((num: number) => -num);\n}\n\n/* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    const maxHeap = new MaxHeap([]);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (let i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (let 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // \u8fd4\u56de\u5806\u4e2d\u5143\u7d20\n    return getMinHeap(maxHeap);\n}\n
    top_k.dart
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nMinHeap topKHeap(List<int> nums, int k) {\n  // \u521d\u59cb\u5316\u5c0f\u9876\u5806\uff0c\u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n  for (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\n    if (nums[i] > heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n
    top_k.rs
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {\n    // BinaryHeap \u662f\u5927\u9876\u5806\uff0c\u4f7f\u7528 Reverse \u5c06\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u5b9e\u73b0\u5c0f\u9876\u5806\n    let mut heap = BinaryHeap::<Reverse<i32>>::new();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for &num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for &num in nums.iter().skip(k) {\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\n        if num > heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n
    top_k.c
    /* \u5143\u7d20\u5165\u5806 */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // \u5143\u7d20\u53d6\u53cd\n    push(maxHeap, -val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nint popMinHeap(MaxHeap *maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -pop(maxHeap);\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -peek(maxHeap);\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // \u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\u5e76\u5b58\u5165 res \u6570\u7ec4\n    int *res = (int *)malloc(maxHeap->size * sizeof(int));\n    for (int i = 0; i < maxHeap->size; i++) {\n        res[i] = -maxHeap->data[i];\n    }\n    return res;\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // \u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\u5e76\u5b58\u5165 res \u6570\u7ec4\n    int *res = (int *)malloc(maxHeap->size * sizeof(int));\n    for (int i = 0; i < maxHeap->size; i++) {\n        res[i] = -maxHeap->data[i];\n    }\n    return res;\n}\n\n// \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20\u7684\u51fd\u6570\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (int i = k; i < sizeNums; 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // \u91ca\u653e\u5185\u5b58\n    delMaxHeap(maxHeap);\n    return res;\n}\n
    top_k.kt
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfun topKHeap(nums: IntArray, k: Int): Queue<Int> {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    val heap = PriorityQueue<Int>()\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (i in 0..<k) {\n        heap.offer(nums[i])\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (i in k..<nums.size) {\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\n        if (nums[i] > heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n
    top_k.rb
    [class]{}-[func]{top_k_heap}\n
    top_k.zig
    [class]{}-[func]{topKHeap}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\u7684 \\(k\\) \u4e2a\u5143\u7d20\u7684\u52a8\u6001\u66f4\u65b0\u3002

    "},{"location":"chapter_introduction/","title":"\u7b2c 1 \u7ae0 \u00a0 \u521d\u8bc6\u7b97\u6cd5","text":"

    Abstract

    \u4e00\u4f4d\u5c11\u5973\u7fe9\u7fe9\u8d77\u821e\uff0c\u4e0e\u6570\u636e\u4ea4\u7ec7\u5728\u4e00\u8d77\uff0c\u88d9\u6446\u4e0a\u98d8\u626c\u7740\u7b97\u6cd5\u7684\u65cb\u5f8b\u3002

    \u5979\u9080\u8bf7\u4f60\u5171\u821e\uff0c\u8bf7\u7d27\u8ddf\u5979\u7684\u6b65\u4f10\uff0c\u8e0f\u5165\u5145\u6ee1\u903b\u8f91\u4e0e\u7f8e\u611f\u7684\u7b97\u6cd5\u4e16\u754c\u3002

    \u8ba1\u7b97\u673a\u7684\u51fa\u73b0\u7ed9\u4e16\u754c\u5e26\u6765\u4e86\u5de8\u5927\u53d8\u9769\uff0c\u5b83\u51ed\u501f\u9ad8\u901f\u7684\u8ba1\u7b97\u80fd\u529b\u548c\u51fa\u8272\u7684\u53ef\u7f16\u7a0b\u6027\uff0c\u6210\u4e3a\u4e86\u6267\u884c\u7b97\u6cd5\u4e0e\u5904\u7406\u6570\u636e\u7684\u7406\u60f3\u5a92\u4ecb\u3002\u65e0\u8bba\u662f\u7535\u5b50\u6e38\u620f\u7684\u903c\u771f\u753b\u9762\u3001\u81ea\u52a8\u9a7e\u9a76\u7684\u667a\u80fd\u51b3\u7b56\uff0c\u8fd8\u662f AlphaGo \u7684\u7cbe\u5f69\u68cb\u5c40\u3001ChatGPT \u7684\u81ea\u7136\u4ea4\u4e92\uff0c\u8fd9\u4e9b\u5e94\u7528\u90fd\u662f\u7b97\u6cd5\u5728\u8ba1\u7b97\u673a\u4e0a\u7684\u7cbe\u5999\u6f14\u7ece\u3002

    \u4e8b\u5b9e\u4e0a\uff0c\u5728\u8ba1\u7b97\u673a\u95ee\u4e16\u4e4b\u524d\uff0c\u7b97\u6cd5\u548c\u6570\u636e\u7ed3\u6784\u5c31\u5df2\u7ecf\u5b58\u5728\u4e8e\u4e16\u754c\u7684\u5404\u4e2a\u89d2\u843d\u3002\u65e9\u671f\u7684\u7b97\u6cd5\u76f8\u5bf9\u7b80\u5355\uff0c\u4f8b\u5982\u53e4\u4ee3\u7684\u8ba1\u6570\u65b9\u6cd5\u548c\u5de5\u5177\u5236\u4f5c\u6b65\u9aa4\u7b49\u3002\u968f\u7740\u6587\u660e\u7684\u8fdb\u6b65\uff0c\u7b97\u6cd5\u9010\u6e10\u53d8\u5f97\u66f4\u52a0\u7cbe\u7ec6\u548c\u590d\u6742\u3002\u4ece\u5de7\u593a\u5929\u5de5\u7684\u5320\u4eba\u6280\u827a\u3001\u5230\u89e3\u653e\u751f\u4ea7\u529b\u7684\u5de5\u4e1a\u4ea7\u54c1\u3001\u518d\u5230\u5b87\u5b99\u8fd0\u884c\u7684\u79d1\u5b66\u89c4\u5f8b\uff0c\u51e0\u4e4e\u6bcf\u4e00\u4ef6\u5e73\u51e1\u6216\u4ee4\u4eba\u60ca\u53f9\u7684\u4e8b\u7269\u80cc\u540e\uff0c\u90fd\u9690\u85cf\u7740\u7cbe\u5999\u7684\u7b97\u6cd5\u601d\u60f3\u3002

    \u540c\u6837\uff0c\u6570\u636e\u7ed3\u6784\u65e0\u5904\u4e0d\u5728\uff1a\u5927\u5230\u793e\u4f1a\u7f51\u7edc\uff0c\u5c0f\u5230\u5730\u94c1\u7ebf\u8def\uff0c\u8bb8\u591a\u7cfb\u7edf\u90fd\u53ef\u4ee5\u5efa\u6a21\u4e3a\u201c\u56fe\u201d\uff1b\u5927\u5230\u4e00\u4e2a\u56fd\u5bb6\uff0c\u5c0f\u5230\u4e00\u4e2a\u5bb6\u5ead\uff0c\u793e\u4f1a\u7684\u4e3b\u8981\u7ec4\u7ec7\u5f62\u5f0f\u5448\u73b0\u51fa\u201c\u6811\u201d\u7684\u7279\u5f81\uff1b\u51ac\u5929\u7684\u8863\u670d\u5c31\u50cf\u201c\u6808\u201d\uff0c\u6700\u5148\u7a7f\u4e0a\u7684\u6700\u540e\u624d\u80fd\u8131\u4e0b\uff1b\u7fbd\u6bdb\u7403\u7b52\u5219\u5982\u540c\u201c\u961f\u5217\u201d\uff0c\u4e00\u7aef\u653e\u5165\u3001\u53e6\u4e00\u7aef\u53d6\u51fa\uff1b\u5b57\u5178\u5c31\u50cf\u4e00\u4e2a\u201c\u54c8\u5e0c\u8868\u201d\uff0c\u80fd\u591f\u5feb\u901f\u67e5\u627e\u76ee\u6807\u8bcd\u6761\u3002

    \u90a3\u4e48\uff0c\u4ec0\u4e48\u662f\u7b97\u6cd5\uff0c\u5b83\u5728\u6211\u4eec\u65e5\u5e38\u751f\u6d3b\u4e2d\u626e\u6f14\u7740\u600e\u6837\u7684\u89d2\u8272\uff1f\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u5c31\u8fd9\u4e9b\u95ee\u9898\u5c55\u5f00\u63a2\u8ba8\u3002

    "},{"location":"chapter_introduction/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 1.1 \u00a0 \u7b97\u6cd5\u65e0\u5904\u4e0d\u5728
    • 1.2 \u00a0 \u7b97\u6cd5\u662f\u4ec0\u4e48
    • 1.3 \u00a0 \u5c0f\u7ed3
    "},{"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\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\u6211\u5c06\u4e3e\u51e0\u4e2a\u5177\u4f53\u7684\u4f8b\u5b50\u6765\u8bc1\u5b9e\u8fd9\u4e00\u70b9\u3002

    \u4f8b\u4e00\uff1a\u67e5\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\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\u6309\u7167\u56fe 1-1 \u6240\u793a\u7684\u65b9\u5f0f\u5b9e\u73b0\u3002

    1. \u7ffb\u5f00\u5b57\u5178\u7ea6\u4e00\u534a\u7684\u9875\u6570\uff0c\u67e5\u770b\u8be5\u9875\u7684\u9996\u5b57\u6bcd\u662f\u4ec0\u4e48\uff0c\u5047\u8bbe\u9996\u5b57\u6bcd\u4e3a \\(m\\) \u3002
    2. \u7531\u4e8e\u5728\u62fc\u97f3\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\u3002
    3. \u4e0d\u65ad\u91cd\u590d\u6b65\u9aa4 1. \u548c \u6b65\u9aa4 2. \uff0c\u76f4\u81f3\u627e\u5230\u62fc\u97f3\u9996\u5b57\u6bcd\u4e3a \\(r\\) \u7684\u9875\u7801\u4e3a\u6b62\u3002
    <1><2><3><4><5>

    \u56fe 1-1 \u00a0 \u67e5\u5b57\u5178\u6b65\u9aa4

    \u67e5\u5b57\u5178\u8fd9\u4e2a\u5c0f\u5b66\u751f\u5fc5\u5907\u6280\u80fd\uff0c\u5b9e\u9645\u4e0a\u5c31\u662f\u8457\u540d\u7684\u201c\u4e8c\u5206\u67e5\u627e\u201d\u7b97\u6cd5\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\u201c\u6570\u7ec4\u201d\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\u201c\u4e8c\u5206\u67e5\u627e\u201d\u3002

    \u4f8b\u4e8c\uff1a\u6574\u7406\u6251\u514b\u3002\u6211\u4eec\u5728\u6253\u724c\u65f6\uff0c\u6bcf\u5c40\u90fd\u9700\u8981\u6574\u7406\u624b\u4e2d\u7684\u6251\u514b\u724c\uff0c\u4f7f\u5176\u4ece\u5c0f\u5230\u5927\u6392\u5217\uff0c\u5b9e\u73b0\u6d41\u7a0b\u5982\u56fe 1-2 \u6240\u793a\u3002

    1. \u5c06\u6251\u514b\u724c\u5212\u5206\u4e3a\u201c\u6709\u5e8f\u201d\u548c\u201c\u65e0\u5e8f\u201d\u4e24\u90e8\u5206\uff0c\u5e76\u5047\u8bbe\u521d\u59cb\u72b6\u6001\u4e0b\u6700\u5de6 1 \u5f20\u6251\u514b\u724c\u5df2\u7ecf\u6709\u5e8f\u3002
    2. \u5728\u65e0\u5e8f\u90e8\u5206\u62bd\u51fa\u4e00\u5f20\u6251\u514b\u724c\uff0c\u63d2\u5165\u81f3\u6709\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\uff1b\u5b8c\u6210\u540e\u6700\u5de6 2 \u5f20\u6251\u514b\u5df2\u7ecf\u6709\u5e8f\u3002
    3. \u4e0d\u65ad\u5faa\u73af\u6b65\u9aa4 2. \uff0c\u6bcf\u4e00\u8f6e\u5c06\u4e00\u5f20\u6251\u514b\u724c\u4ece\u65e0\u5e8f\u90e8\u5206\u63d2\u5165\u81f3\u6709\u5e8f\u90e8\u5206\uff0c\u76f4\u81f3\u6240\u6709\u6251\u514b\u724c\u90fd\u6709\u5e8f\u3002

    \u56fe 1-2 \u00a0 \u6251\u514b\u6392\u5e8f\u6b65\u9aa4

    \u4e0a\u8ff0\u6574\u7406\u6251\u514b\u724c\u7684\u65b9\u6cd5\u672c\u8d28\u4e0a\u662f\u201c\u63d2\u5165\u6392\u5e8f\u201d\u7b97\u6cd5\uff0c\u5b83\u5728\u5904\u7406\u5c0f\u578b\u6570\u636e\u96c6\u65f6\u975e\u5e38\u9ad8\u6548\u3002\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\u7684\u6392\u5e8f\u5e93\u51fd\u6570\u4e2d\u90fd\u6709\u63d2\u5165\u6392\u5e8f\u7684\u8eab\u5f71\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\u4e86\u6536\u94f6\u5458 \\(100\\) \u5143\uff0c\u5219\u6536\u94f6\u5458\u9700\u8981\u627e\u6211\u4eec \\(31\\) \u5143\u3002\u4ed6\u4f1a\u5f88\u81ea\u7136\u5730\u5b8c\u6210\u5982\u56fe 1-3 \u6240\u793a\u7684\u601d\u8003\u3002

    1. \u53ef\u9009\u9879\u662f\u6bd4 \\(31\\) \u5143\u9762\u503c\u66f4\u5c0f\u7684\u8d27\u5e01\uff0c\u5305\u62ec \\(1\\) \u5143\u3001\\(5\\) \u5143\u3001\\(10\\) \u5143\u3001\\(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

    \u56fe 1-3 \u00a0 \u8d27\u5e01\u627e\u96f6\u8fc7\u7a0b

    \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\u201c\u8d2a\u5fc3\u201d\u7b97\u6cd5\u3002

    \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\u5f97\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

    \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\u8bf7\u7ee7\u7eed\u5f80\u4e0b\u9605\u8bfb\uff0c\u672c\u4e66\u5c06\u5f15\u5bfc\u4f60\u8fc8\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\u5b57\u5178\u7684\u539f\u7406\u4e0e\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u76f8\u4e00\u81f4\u3002\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u4f53\u73b0\u4e86\u5206\u800c\u6cbb\u4e4b\u7684\u91cd\u8981\u7b97\u6cd5\u601d\u60f3\u3002
    • \u6574\u7406\u6251\u514b\u7684\u8fc7\u7a0b\u4e0e\u63d2\u5165\u6392\u5e8f\u7b97\u6cd5\u975e\u5e38\u7c7b\u4f3c\u3002\u63d2\u5165\u6392\u5e8f\u7b97\u6cd5\u9002\u5408\u6392\u5e8f\u5c0f\u578b\u6570\u636e\u96c6\u3002
    • \u8d27\u5e01\u627e\u96f6\u7684\u6b65\u9aa4\u672c\u8d28\u4e0a\u662f\u8d2a\u5fc3\u7b97\u6cd5\uff0c\u6bcf\u4e00\u6b65\u90fd\u91c7\u53d6\u5f53\u524d\u770b\u6765\u6700\u597d\u7684\u9009\u62e9\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\u662f\u6570\u636e\u7ed3\u6784\u53d1\u6325\u4f5c\u7528\u7684\u821e\u53f0\u3002
    • \u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7c7b\u6bd4\u4e3a\u62fc\u88c5\u79ef\u6728\uff0c\u79ef\u6728\u4ee3\u8868\u6570\u636e\uff0c\u79ef\u6728\u7684\u5f62\u72b6\u548c\u8fde\u63a5\u65b9\u5f0f\u7b49\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\uff0c\u5b83\u5177\u6709\u4ee5\u4e0b\u7279\u6027\u3002

    • \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\u5728\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\uff0c\u5177\u6709\u4ee5\u4e0b\u8bbe\u8ba1\u76ee\u6807\u3002

    • \u7a7a\u95f4\u5360\u7528\u5c3d\u91cf\u5c11\uff0c\u4ee5\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\u7b97\u6cd5\u9ad8\u6548\u8fd0\u884c\u3002

    \u6570\u636e\u7ed3\u6784\u8bbe\u8ba1\u662f\u4e00\u4e2a\u5145\u6ee1\u6743\u8861\u7684\u8fc7\u7a0b\u3002\u5982\u679c\u60f3\u5728\u67d0\u65b9\u9762\u53d6\u5f97\u63d0\u5347\uff0c\u5f80\u5f80\u9700\u8981\u5728\u53e6\u4e00\u65b9\u9762\u4f5c\u51fa\u59a5\u534f\u3002\u4e0b\u9762\u4e3e\u4e24\u4e2a\u4f8b\u5b50\u3002

    • \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\u3002
    • \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":"

    \u5982\u56fe 1-4 \u6240\u793a\uff0c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u9ad8\u5ea6\u76f8\u5173\u3001\u7d27\u5bc6\u7ed3\u5408\uff0c\u5177\u4f53\u8868\u73b0\u5728\u4ee5\u4e0b\u4e09\u4e2a\u65b9\u9762\u3002

    • \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\u64cd\u4f5c\u6570\u636e\u7684\u65b9\u6cd5\u3002
    • \u7b97\u6cd5\u662f\u6570\u636e\u7ed3\u6784\u53d1\u6325\u4f5c\u7528\u7684\u821e\u53f0\u3002\u6570\u636e\u7ed3\u6784\u672c\u8eab\u4ec5\u5b58\u50a8\u6570\u636e\u4fe1\u606f\uff0c\u7ed3\u5408\u7b97\u6cd5\u624d\u80fd\u89e3\u51b3\u7279\u5b9a\u95ee\u9898\u3002
    • \u7b97\u6cd5\u901a\u5e38\u53ef\u4ee5\u57fa\u4e8e\u4e0d\u540c\u7684\u6570\u636e\u7ed3\u6784\u5b9e\u73b0\uff0c\u4f46\u6267\u884c\u6548\u7387\u53ef\u80fd\u76f8\u5dee\u5f88\u5927\uff0c\u9009\u62e9\u5408\u9002\u7684\u6570\u636e\u7ed3\u6784\u662f\u5173\u952e\u3002

    \u56fe 1-4 \u00a0 \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u5173\u7cfb

    \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u72b9\u5982\u56fe 1-5 \u6240\u793a\u7684\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

    \u56fe 1-5 \u00a0 \u62fc\u88c5\u79ef\u6728

    \u4e24\u8005\u7684\u8be6\u7ec6\u5bf9\u5e94\u5173\u7cfb\u5982\u8868 1-1 \u6240\u793a\u3002

    \u8868 1-1 \u00a0 \u5c06\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7c7b\u6bd4\u4e3a\u62fc\u88c5\u79ef\u6728

    \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5 \u62fc\u88c5\u79ef\u6728 \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\u8bf4\u660e\u7684\u662f\uff0c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u662f\u72ec\u7acb\u4e8e\u7f16\u7a0b\u8bed\u8a00\u7684\u3002\u6b63\u56e0\u5982\u6b64\uff0c\u672c\u4e66\u5f97\u4ee5\u63d0\u4f9b\u57fa\u4e8e\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\u201c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u201d\u7b80\u79f0\u4e3a\u201c\u7b97\u6cd5\u201d\u3002\u6bd4\u5982\u4f17\u6240\u5468\u77e5\u7684 LeetCode \u7b97\u6cd5\u9898\u76ee\uff0c\u5b9e\u9645\u4e0a\u540c\u65f6\u8003\u67e5\u6570\u636e\u7ed3\u6784\u548c\u7b97\u6cd5\u4e24\u65b9\u9762\u7684\u77e5\u8bc6\u3002

    "},{"location":"chapter_paperbook/","title":"\u7eb8\u8d28\u4e66","text":"

    \u7ecf\u8fc7\u957f\u65f6\u95f4\u7684\u6253\u78e8\uff0c\u300aHello \u7b97\u6cd5\u300b\u7eb8\u8d28\u4e66\u7ec8\u4e8e\u53d1\u5e03\u4e86\uff01\u6b64\u65f6\u7684\u5fc3\u60c5\u53ef\u4ee5\u7528\u4e00\u53e5\u8bd7\u6765\u5f62\u5bb9\uff1a

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

    \u4ee5\u4e0b\u89c6\u9891\u5c55\u793a\u4e86\u7eb8\u8d28\u4e66\uff0c\u5e76\u4e14\u5305\u542b\u6211\u7684\u4e00\u4e9b\u601d\u8003\uff1a

    • \u5b66\u4e60\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u91cd\u8981\u6027\u3002
    • \u4e3a\u4ec0\u4e48\u5728\u7eb8\u8d28\u4e66\u4e2d\u9009\u62e9 Python\u3002
    • \u5bf9\u77e5\u8bc6\u5206\u4eab\u7684\u7406\u89e3\u3002

    \u65b0\u4eba UP \u4e3b\uff0c\u8bf7\u591a\u591a\u5173\u7167\u3001\u4e00\u952e\u4e09\u8fde\uff5e\u8c22\u8c22\uff01

    \u9644\u7eb8\u8d28\u4e66\u5feb\u7167\uff1a

    "},{"location":"chapter_paperbook/#_2","title":"\u4f18\u52bf\u4e0e\u4e0d\u8db3","text":"

    \u603b\u7ed3\u4e00\u4e0b\u7eb8\u8d28\u4e66\u53ef\u80fd\u4f1a\u7ed9\u5927\u5bb6\u5e26\u6765\u60ca\u559c\u7684\u5730\u65b9\uff1a

    • \u91c7\u7528\u5168\u5f69\u5370\u5237\uff0c\u80fd\u591f\u539f\u6c41\u539f\u5473\u5730\u53d1\u6325\u51fa\u672c\u4e66\u201c\u52a8\u753b\u56fe\u89e3\u201d\u7684\u4f18\u52bf\u3002
    • \u8003\u7a76\u7eb8\u5f20\u6750\u8d28\uff0c\u65e2\u4fdd\u8bc1\u8272\u5f69\u9ad8\u5ea6\u8fd8\u539f\uff0c\u4e5f\u4fdd\u7559\u7eb8\u8d28\u4e66\u7279\u6709\u7684\u8d28\u611f\u3002
    • \u5728\u4e0d\u63d0\u5347\u5b9a\u4ef7\u7684\u524d\u63d0\u4e0b\uff0c\u9644\u8d60\u601d\u7ef4\u5bfc\u56fe\u6298\u9875\u3001\u4e66\u7b7e\u3002
    • \u7eb8\u8d28\u4e66\u3001\u7f51\u9875\u7248\u3001PDF \u7248\u5185\u5bb9\u540c\u6b65\uff0c\u968f\u610f\u5207\u6362\u9605\u8bfb\u3002

    Tip

    \u7531\u4e8e\u7eb8\u8d28\u4e66\u548c\u7f51\u9875\u7248\u7684\u540c\u6b65\u6210\u672c\u8f83\u5927\uff0c\u56e0\u6b64\u53ef\u80fd\u4f1a\u6709\u4e00\u4e9b\u7ec6\u8282\u4e0a\u7684\u4e0d\u540c\uff0c\u8bf7\u60a8\u89c1\u8c05\uff01

    \u5f53\u7136\uff0c\u7eb8\u8d28\u4e66\u4e5f\u6709\u4e00\u4e9b\u503c\u5f97\u5927\u5bb6\u5165\u624b\u524d\u8003\u8651\u7684\u5730\u65b9\uff1a

    • \u4f7f\u7528 Python \u8bed\u8a00\uff0c\u53ef\u80fd\u4e0d\u5339\u914d\u4f60\u7684\u4e3b\u8bed\u8a00\uff08\u4e5f\u8bb8\u53ef\u4ee5\u8d81\u6b64\u673a\u4f1a\u7ec3\u4e60 Python\uff09\u3002
    • \u5168\u5f69\u5370\u5237\u867d\u7136\u5927\u5e45\u63d0\u5347\u4e86\u9605\u8bfb\u4f53\u9a8c\uff0c\u4f46\u4ef7\u683c\u4f1a\u6bd4\u9ed1\u767d\u5370\u5237\u9ad8\u4e00\u4e9b\u3002

    Tip

    \u201c\u5370\u5237\u8d28\u91cf\u201d\u548c\u201c\u4ef7\u683c\u201d\u5c31\u50cf\u7b97\u6cd5\u4e2d\u7684\u201c\u65f6\u95f4\u6548\u7387\u201d\u548c\u201c\u7a7a\u95f4\u6548\u7387\u201d\uff0c\u96be\u4ee5\u4e24\u5168\u3002\u800c\u6211\u8ba4\u4e3a\uff0c\u201c\u5370\u5237\u8d28\u91cf\u201d\u5bf9\u5e94\u7684\u662f\u201c\u65f6\u95f4\u6548\u7387\u201d\uff0c\u66f4\u5e94\u8be5\u88ab\u6ce8\u91cd\u3002

    "},{"location":"chapter_paperbook/#_3","title":"\u8d2d\u4e70\u94fe\u63a5","text":"

    \u5982\u679c\u4f60\u5bf9\u7eb8\u8d28\u4e66\u611f\u5174\u8da3\uff0c\u53ef\u4ee5\u8003\u8651\u5165\u624b\u4e00\u672c\u3002\u6211\u4eec\u4e3a\u5927\u5bb6\u4e89\u53d6\u5230\u4e86\u65b0\u4e66 5 \u6298\u4f18\u60e0\uff0c\u8bf7\u89c1\u6b64\u94fe\u63a5\u6216\u626b\u63cf\u4ee5\u4e0b\u4e8c\u7ef4\u7801\uff1a

    "},{"location":"chapter_paperbook/#_4","title":"\u5c3e\u8bb0","text":"

    \u8d77\u521d\uff0c\u6211\u4f4e\u4f30\u4e86\u7eb8\u8d28\u4e66\u51fa\u7248\u7684\u5de5\u4f5c\u91cf\uff0c\u4ee5\u4e3a\u53ea\u8981\u7ef4\u62a4\u597d\u4e86\u5f00\u6e90\u9879\u76ee\uff0c\u7eb8\u8d28\u7248\u5c31\u53ef\u4ee5\u901a\u8fc7\u67d0\u4e9b\u81ea\u52a8\u5316\u624b\u6bb5\u751f\u6210\u51fa\u6765\u3002\u5b9e\u8df5\u8bc1\u660e\uff0c\u7eb8\u8d28\u4e66\u7684\u751f\u4ea7\u6d41\u7a0b\u4e0e\u5f00\u6e90\u9879\u76ee\u7684\u66f4\u65b0\u673a\u5236\u5b58\u5728\u5f88\u5927\u7684\u4e0d\u540c\uff0c\u4e24\u8005\u4e4b\u95f4\u7684\u8f6c\u5316\u9700\u8981\u505a\u8bb8\u591a\u989d\u5916\u5de5\u4f5c\u3002

    \u4e00\u672c\u4e66\u7684\u521d\u7a3f\u4e0e\u8fbe\u5230\u51fa\u7248\u6807\u51c6\u7684\u5b9a\u7a3f\u4e4b\u95f4\u4ecd\u6709\u8f83\u957f\u8ddd\u79bb\uff0c\u9700\u8981\u51fa\u7248\u793e\uff08\u7b56\u5212\u3001\u7f16\u8f91\u3001\u8bbe\u8ba1\u3001\u5e02\u573a\u7b49\uff09\u4e0e\u4f5c\u8005\u7684\u901a\u529b\u5408\u4f5c\u3001\u957f\u671f\u96d5\u7422\u3002\u5728\u6b64\u611f\u8c22\u56fe\u7075\u7b56\u5212\u7f16\u8f91\u738b\u519b\u82b1\u3001\u4ee5\u53ca\u4eba\u6c11\u90ae\u7535\u51fa\u7248\u793e\u548c\u56fe\u7075\u793e\u533a\u6bcf\u4f4d\u53c2\u4e0e\u672c\u4e66\u51fa\u7248\u6d41\u7a0b\u7684\u5de5\u4f5c\u4eba\u5458\uff01

    \u5e0c\u671b\u8fd9\u672c\u4e66\u80fd\u591f\u5e2e\u52a9\u5230\u4f60\uff01

    "},{"location":"chapter_preface/","title":"\u7b2c 0 \u7ae0 \u00a0 \u524d\u8a00","text":"

    Abstract

    \u7b97\u6cd5\u72b9\u5982\u7f8e\u5999\u7684\u4ea4\u54cd\u4e50\uff0c\u6bcf\u4e00\u884c\u4ee3\u7801\u90fd\u50cf\u97f5\u5f8b\u822c\u6d41\u6dcc\u3002

    \u613f\u8fd9\u672c\u4e66\u5728\u4f60\u7684\u8111\u6d77\u4e2d\u8f7b\u8f7b\u54cd\u8d77\uff0c\u7559\u4e0b\u72ec\u7279\u800c\u6df1\u523b\u7684\u65cb\u5f8b\u3002

    \u4e24\u5e74\u524d\uff0c\u6211\u5728\u529b\u6263\u4e0a\u5206\u4eab\u4e86\u201c\u5251\u6307 Offer\u201d\u7cfb\u5217\u9898\u89e3\uff0c\u53d7\u5230\u4e86\u8bb8\u591a\u8bfb\u8005\u7684\u9f13\u52b1\u548c\u652f\u6301\u3002\u5728\u4e0e\u8bfb\u8005\u4ea4\u6d41\u671f\u95f4\uff0c\u6211\u6700\u5e38\u88ab\u95ee\u7684\u4e00\u4e2a\u95ee\u9898\u662f\u201c\u5982\u4f55\u5165\u95e8\u7b97\u6cd5\u201d\u3002\u9010\u6e10\u5730\uff0c\u6211\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\u3001\u76f4\u63a5\u4e14\u6709\u6548\u3002\u7136\u800c\u5237\u9898\u5c31\u5982\u540c\u73a9\u201c\u626b\u96f7\u201d\u6e38\u620f\uff0c\u81ea\u5b66\u80fd\u529b\u5f3a\u7684\u4eba\u80fd\u591f\u987a\u5229\u5c06\u5730\u96f7\u9010\u4e2a\u6392\u6389\uff0c\u800c\u57fa\u7840\u4e0d\u8db3\u7684\u4eba\u5f88\u53ef\u80fd\u88ab\u70b8\u5f97\u6ee1\u5934\u662f\u5305\uff0c\u5e76\u5728\u632b\u6298\u4e2d\u6b65\u6b65\u9000\u7f29\u3002\u901a\u8bfb\u6559\u6750\u4e5f\u662f\u4e00\u79cd\u5e38\u89c1\u505a\u6cd5\uff0c\u4f46\u5bf9\u4e8e\u9762\u5411\u6c42\u804c\u7684\u4eba\u6765\u8bf4\uff0c\u6bd5\u4e1a\u8bba\u6587\u3001\u6295\u9012\u7b80\u5386\u3001\u51c6\u5907\u7b14\u8bd5\u548c\u9762\u8bd5\u5df2\u7ecf\u6d88\u8017\u4e86\u5927\u90e8\u5206\u7cbe\u529b\uff0c\u5543\u539a\u91cd\u7684\u4e66\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\u201c\u627e\u201d\u5230\u4e86\u4f60\u3002\u672c\u4e66\u662f\u6211\u5bf9\u8fd9\u4e2a\u95ee\u9898\u7ed9\u51fa\u7684\u7b54\u6848\uff0c\u5373\u4f7f\u4e0d\u662f\u6700\u4f18\u89e3\uff0c\u4e5f\u81f3\u5c11\u662f\u4e00\u6b21\u79ef\u6781\u7684\u5c1d\u8bd5\u3002\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\u3001\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\u5237\u9898\u548c\u9605\u8bfb\u6587\u732e\uff0c\u9010\u6b65\u6784\u5efa\u8d77\u5b8c\u6574\u7684\u77e5\u8bc6\u4f53\u7cfb\u3002

    \u6211\u6df1\u6df1\u8d5e\u540c\u8d39\u66fc\u6559\u6388\u6240\u8a00\uff1a\u201cKnowledge isn't free. You have to pay attention.\u201d\u4ece\u8fd9\u4e2a\u610f\u4e49\u4e0a\u770b\uff0c\u8fd9\u672c\u4e66\u5e76\u975e\u5b8c\u5168\u201c\u514d\u8d39\u201d\u3002\u4e3a\u4e86\u4e0d\u8f9c\u8d1f\u4f60\u4e3a\u672c\u4e66\u6240\u4ed8\u51fa\u7684\u5b9d\u8d35\u201c\u6ce8\u610f\u529b\u201d\uff0c\u6211\u4f1a\u7aed\u5c3d\u6240\u80fd\uff0c\u6295\u5165\u6700\u5927\u7684\u201c\u6ce8\u610f\u529b\u201d\u6765\u5b8c\u6210\u672c\u4e66\u7684\u521b\u4f5c\u3002

    "},{"location":"chapter_preface/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 0.1 \u00a0 \u5173\u4e8e\u672c\u4e66
    • 0.2 \u00a0 \u5982\u4f55\u4f7f\u7528\u672c\u4e66
    • 0.3 \u00a0 \u5c0f\u7ed3
    "},{"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\u3001\u514d\u8d39\u3001\u5bf9\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\uff0c\u5b66\u4e60\u66f2\u7ebf\u5e73\u6ed1\u3002
    • \u7b97\u6cd5\u6e90\u4ee3\u7801\u7686\u53ef\u4e00\u952e\u8fd0\u884c\uff0c\u652f\u6301 Python\u3001C++\u3001Java\u3001C#\u3001Go\u3001Swift\u3001JavaScript\u3001TypeScript\u3001Dart\u3001Rust\u3001C \u548c Zig \u7b49\u8bed\u8a00\u3002
    • \u9f13\u52b1\u8bfb\u8005\u5728\u7ebf\u4e0a\u7ae0\u8282\u8bc4\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\u3002
    "},{"location":"chapter_preface/about_the_book/#011","title":"0.1.1 \u00a0 \u8bfb\u8005\u5bf9\u8c61","text":"

    \u82e5\u4f60\u662f\u7b97\u6cd5\u521d\u5b66\u8005\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\u672c\u4e66\u6b63\u662f\u4e3a\u4f60\u91cf\u8eab\u5b9a\u5236\u7684\uff01

    \u5982\u679c\u4f60\u5df2\u7ecf\u79ef\u7d2f\u4e00\u5b9a\u7684\u5237\u9898\u91cf\uff0c\u719f\u6089\u5927\u90e8\u5206\u9898\u578b\uff0c\u90a3\u4e48\u672c\u4e66\u53ef\u52a9\u4f60\u56de\u987e\u4e0e\u68b3\u7406\u7b97\u6cd5\u77e5\u8bc6\u4f53\u7cfb\uff0c\u4ed3\u5e93\u6e90\u4ee3\u7801\u53ef\u4ee5\u5f53\u4f5c\u201c\u5237\u9898\u5de5\u5177\u5e93\u201d\u6216\u201c\u7b97\u6cd5\u5b57\u5178\u201d\u6765\u4f7f\u7528\u3002

    \u82e5\u4f60\u662f\u7b97\u6cd5\u201c\u5927\u795e\u201d\uff0c\u6211\u4eec\u671f\u5f85\u6536\u5230\u4f60\u7684\u5b9d\u8d35\u5efa\u8bae\uff0c\u6216\u8005\u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c\u3002

    \u524d\u7f6e\u6761\u4ef6

    \u4f60\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\u7684\u4e3b\u8981\u5185\u5bb9\u5982\u56fe 0-1 \u6240\u793a\u3002

    • \u590d\u6742\u5ea6\u5206\u6790\uff1a\u6570\u636e\u7ed3\u6784\u548c\u7b97\u6cd5\u7684\u8bc4\u4ef7\u7ef4\u5ea6\u4e0e\u65b9\u6cd5\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u63a8\u7b97\u65b9\u6cd5\u3001\u5e38\u89c1\u7c7b\u578b\u3001\u793a\u4f8b\u7b49\u3002
    • \u6570\u636e\u7ed3\u6784\uff1a\u57fa\u672c\u6570\u636e\u7c7b\u578b\u548c\u6570\u636e\u7ed3\u6784\u7684\u5206\u7c7b\u65b9\u6cd5\u3002\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u7b49\u6570\u636e\u7ed3\u6784\u7684\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\u641c\u7d22\u3001\u6392\u5e8f\u3001\u5206\u6cbb\u3001\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\u3001\u8d2a\u5fc3\u7b49\u7b97\u6cd5\u7684\u5b9a\u4e49\u3001\u4f18\u7f3a\u70b9\u3001\u6548\u7387\u3001\u5e94\u7528\u573a\u666f\u3001\u89e3\u9898\u6b65\u9aa4\u548c\u793a\u4f8b\u95ee\u9898\u7b49\u3002

    \u56fe 0-1 \u00a0 \u672c\u4e66\u4e3b\u8981\u5185\u5bb9

    "},{"location":"chapter_preface/about_the_book/#013","title":"0.1.3 \u00a0 \u81f4\u8c22","text":"

    \u672c\u4e66\u5728\u5f00\u6e90\u793e\u533a\u4f17\u591a\u8d21\u732e\u8005\u7684\u5171\u540c\u52aa\u529b\u4e0b\u4e0d\u65ad\u5b8c\u5584\u3002\u611f\u8c22\u6bcf\u4e00\u4f4d\u6295\u5165\u65f6\u95f4\u4e0e\u7cbe\u529b\u7684\u64b0\u7a3f\u4eba\uff0c\u4ed6\u4eec\u662f\uff08\u6309\u7167 GitHub \u81ea\u52a8\u751f\u6210\u7684\u987a\u5e8f\uff09\uff1akrahets\u3001codingonion\u3001nuomi1\u3001Gonglja\u3001Reanon\u3001justin-tse\u3001danielsss\u3001hpstory\u3001S-N-O-R-L-A-X\u3001night-cruise\u3001msk397\u3001gvenusleo\u3001RiverTwilight\u3001gyt95\u3001zhuoqinyue\u3001Zuoxun\u3001Xia-Sang\u3001mingXta\u3001FangYuan33\u3001GN-Yu\u3001IsChristina\u3001xBLACKICEx\u3001guowei-gong\u3001Cathay-Chen\u3001mgisr\u3001JoseHung\u3001qualifier1024\u3001pengchzn\u3001Guanngxu\u3001longsizhuo\u3001L-Super\u3001what-is-me\u3001yuan0221\u3001lhxsm\u3001Slone123c\u3001WSL0809\u3001longranger2\u3001theNefelibatas\u3001xiongsp\u3001JeffersonHuang\u3001hongyun-robot\u3001K3v123\u3001yuelinxin\u3001a16su\u3001gaofer\u3001malone6\u3001Wonderdch\u3001xjr7670\u3001DullSword\u3001Horbin-Magician\u3001NI-SW\u3001reeswell\u3001XC-Zero\u3001XiaChuerwu\u3001yd-j\u3001iron-irax\u3001huawuque404\u3001MolDuM\u3001Nigh\u3001KorsChen\u3001foursevenlove\u300152coder\u3001bubble9um\u3001youshaoXG\u3001curly210102\u3001gltianwen\u3001fanchenggang\u3001Transmigration-zhou\u3001FloranceYeh\u3001FreddieLi\u3001ShiMaRing\u3001lipusheng\u3001Javesun99\u3001JackYang-hellobobo\u3001shanghai-Jerry\u30010130w\u3001Keynman\u3001psychelzh\u3001logan-qiu\u3001ZnYang2018\u3001MwumLi\u30011ch0\u3001Phoenix0415\u3001qingpeng9802\u3001Richard-Zhang1019\u3001QiLOL\u3001Suremotoo\u3001Turing-1024-Lee\u3001Evilrabbit520\u3001GaochaoZhu\u3001ZJKung\u3001linzeyan\u3001hezhizhen\u3001ZongYangL\u3001beintentional\u3001czruby\u3001coderlef\u3001dshlstarr\u3001szu17dmy\u3001fbigm\u3001gledfish\u3001hts0000\u3001boloboloda\u3001iStig\u3001jiaxianhua\u3001wenjianmin\u3001keshida\u3001kilikilikid\u3001lclc6\u3001lwbaptx\u3001liuxjerry\u3001lucaswangdev\u3001lyl625760\u3001chadyi\u3001noobcodemaker\u3001selear\u3001siqyka\u3001syd168\u30014yDX3906\u3001tao363\u3001wangwang105\u3001weibk\u3001yabo083\u3001yi427\u3001yishangzhang\u3001zhouLion\u3001baagod\u3001ElaBosak233\u3001xb534\u3001luluxia\u3001yanedie\u3001thomasq0\u3001YangXuanyi \u548c th1nk3r-ing \u3002

    \u672c\u4e66\u7684\u4ee3\u7801\u5ba1\u9605\u5de5\u4f5c\u7531 codingonion\u3001Gonglja\u3001gvenusleo\u3001hpstory\u3001justin-tse\u3001krahets\u3001night-cruise\u3001nuomi1 \u548c Reanon \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

    \u5728\u672c\u4e66\u7684\u521b\u4f5c\u8fc7\u7a0b\u4e2d\uff0c\u6211\u5f97\u5230\u4e86\u8bb8\u591a\u4eba\u7684\u5e2e\u52a9\u3002

    • \u611f\u8c22\u6211\u5728\u516c\u53f8\u7684\u5bfc\u5e08\u674e\u6c50\u535a\u58eb\uff0c\u5728\u4e00\u6b21\u7545\u8c08\u4e2d\u4f60\u9f13\u52b1\u6211\u201c\u5feb\u884c\u52a8\u8d77\u6765\u201d\uff0c\u575a\u5b9a\u4e86\u6211\u5199\u8fd9\u672c\u4e66\u7684\u51b3\u5fc3\uff1b
    • \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\uff1b
    • \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\u201cHello World!\u201d\u7684\u7f8e\u597d\u56de\u5fc6\uff1b
    • \u611f\u8c22\u6821\u94e8\u5728\u77e5\u8bc6\u4ea7\u6743\u65b9\u9762\u63d0\u4f9b\u7684\u4e13\u4e1a\u5e2e\u52a9\uff0c\u8fd9\u5bf9\u672c\u5f00\u6e90\u4e66\u7684\u5b8c\u5584\u8d77\u5230\u4e86\u91cd\u8981\u4f5c\u7528\uff1b
    • \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\u7684\u9a71\u4f7f\u4e0b\u591a\u6b21\u8010\u5fc3\u4fee\u6539\uff1b
    • \u611f\u8c22 @squidfunk \u63d0\u4f9b\u7684\u6392\u7248\u5efa\u8bae\uff0c\u4ee5\u53ca\u4ed6\u5f00\u53d1\u7684\u5f00\u6e90\u6587\u6863\u4e3b\u9898 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\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\u6211\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\u7684\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\u4ef6\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\u4f60\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\u53ef\u4ee5\u5148\u8df3\u8fc7\u3002
    • \u91cd\u8981\u4e13\u6709\u540d\u8bcd\u53ca\u5176\u82f1\u6587\u7ffb\u8bd1\u4f1a\u7528 \u300c \u300d \u62ec\u53f7\u6807\u6ce8\uff0c\u4f8b\u5982 \u300c\u6570\u7ec4 array\u300d \u3002\u5efa\u8bae\u8bb0\u4f4f\u5b83\u4eec\uff0c\u4ee5\u4fbf\u9605\u8bfb\u6587\u732e\u3002
    • \u4e13\u6709\u540d\u8bcd\u548c\u6709\u7279\u6307\u542b\u4e49\u7684\u8bcd\u53e5\u4f1a\u4f7f\u7528 \u201c\u5f15\u53f7\u201d \u6807\u6ce8\uff0c\u4ee5\u907f\u514d\u6b67\u4e49\u3002
    • \u91cd\u8981\u540d\u8bcd\u3001\u91cd\u70b9\u5185\u5bb9\u548c\u603b\u7ed3\u6027\u8bed\u53e5\u4f1a \u52a0\u7c97 \uff0c\u8fd9\u7c7b\u6587\u5b57\u503c\u5f97\u7279\u522b\u5173\u6ce8\u3002
    • \u5f53\u6d89\u53ca\u7f16\u7a0b\u8bed\u8a00\u4e4b\u95f4\u4e0d\u4e00\u81f4\u7684\u540d\u8bcd\u65f6\uff0c\u672c\u4e66\u5747\u4ee5 Python \u4e3a\u51c6\uff0c\u4f8b\u5982\u4f7f\u7528 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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    \"\"\"\u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49\"\"\"\n\n# \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    \n
    // \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49\n\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\n// \u591a\u884c\n// \u6ce8\u91ca\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\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\u4ee5\u56fe\u89e3\u5f62\u5f0f\u5c55\u793a\uff0c\u800c\u6587\u5b57\u5219\u4f5c\u4e3a\u89e3\u91ca\u4e0e\u8865\u5145\u3002

    \u5982\u679c\u4f60\u5728\u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u53d1\u73b0\u67d0\u6bb5\u5185\u5bb9\u63d0\u4f9b\u4e86\u5982\u56fe 0-2 \u6240\u793a\u7684\u52a8\u753b\u56fe\u89e3\uff0c\u8bf7\u4ee5\u56fe\u4e3a\u4e3b\u3001\u4ee5\u6587\u5b57\u4e3a\u8f85\uff0c\u7efc\u5408\u4e24\u8005\u6765\u7406\u89e3\u5185\u5bb9\u3002

    \u56fe 0-2 \u00a0 \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\u5728 GitHub \u4ed3\u5e93\u3002\u5982\u56fe 0-3 \u6240\u793a\uff0c\u6e90\u4ee3\u7801\u9644\u6709\u6d4b\u8bd5\u6837\u4f8b\uff0c\u53ef\u4e00\u952e\u8fd0\u884c\u3002

    \u5982\u679c\u65f6\u95f4\u5141\u8bb8\uff0c\u5efa\u8bae\u4f60\u53c2\u7167\u4ee3\u7801\u81ea\u884c\u6572\u4e00\u904d\u3002\u5982\u679c\u5b66\u4e60\u65f6\u95f4\u6709\u9650\uff0c\u8bf7\u81f3\u5c11\u901a\u8bfb\u5e76\u8fd0\u884c\u6240\u6709\u4ee3\u7801\u3002

    \u4e0e\u9605\u8bfb\u4ee3\u7801\u76f8\u6bd4\uff0c\u7f16\u5199\u4ee3\u7801\u7684\u8fc7\u7a0b\u5f80\u5f80\u80fd\u5e26\u6765\u66f4\u591a\u6536\u83b7\u3002\u52a8\u624b\u5b66\uff0c\u624d\u662f\u771f\u7684\u5b66\u3002

    \u56fe 0-3 \u00a0 \u8fd0\u884c\u4ee3\u7801\u793a\u4f8b

    \u8fd0\u884c\u4ee3\u7801\u7684\u524d\u7f6e\u5de5\u4f5c\u4e3b\u8981\u5206\u4e3a\u4e09\u6b65\u3002

    \u7b2c\u4e00\u6b65\uff1a\u5b89\u88c5\u672c\u5730\u7f16\u7a0b\u73af\u5883\u3002\u8bf7\u53c2\u7167\u9644\u5f55\u6240\u793a\u7684\u6559\u7a0b\u8fdb\u884c\u5b89\u88c5\uff0c\u5982\u679c\u5df2\u5b89\u88c5\uff0c\u5219\u53ef\u8df3\u8fc7\u6b64\u6b65\u9aa4\u3002

    \u7b2c\u4e8c\u6b65\uff1a\u514b\u9686\u6216\u4e0b\u8f7d\u4ee3\u7801\u4ed3\u5e93\u3002\u524d\u5f80 GitHub \u4ed3\u5e93\u3002\u5982\u679c\u5df2\u7ecf\u5b89\u88c5 Git \uff0c\u53ef\u4ee5\u901a\u8fc7\u4ee5\u4e0b\u547d\u4ee4\u514b\u9686\u672c\u4ed3\u5e93\uff1a

    git clone https://github.com/krahets/hello-algo.git\n

    \u5f53\u7136\uff0c\u4f60\u4e5f\u53ef\u4ee5\u5728\u56fe 0-4 \u6240\u793a\u7684\u4f4d\u7f6e\uff0c\u70b9\u51fb\u201cDownload ZIP\u201d\u6309\u94ae\u76f4\u63a5\u4e0b\u8f7d\u4ee3\u7801\u538b\u7f29\u5305\uff0c\u7136\u540e\u5728\u672c\u5730\u89e3\u538b\u5373\u53ef\u3002

    \u56fe 0-4 \u00a0 \u514b\u9686\u4ed3\u5e93\u4e0e\u4e0b\u8f7d\u4ee3\u7801

    \u7b2c\u4e09\u6b65\uff1a\u8fd0\u884c\u6e90\u4ee3\u7801\u3002\u5982\u56fe 0-5 \u6240\u793a\uff0c\u5bf9\u4e8e\u9876\u90e8\u6807\u6709\u6587\u4ef6\u540d\u79f0\u7684\u4ee3\u7801\u5757\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u4ed3\u5e93\u7684 codes \u6587\u4ef6\u5939\u5185\u627e\u5230\u5bf9\u5e94\u7684\u6e90\u4ee3\u7801\u6587\u4ef6\u3002\u6e90\u4ee3\u7801\u6587\u4ef6\u53ef\u4e00\u952e\u8fd0\u884c\uff0c\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

    \u56fe 0-5 \u00a0 \u4ee3\u7801\u5757\u4e0e\u5bf9\u5e94\u7684\u6e90\u4ee3\u7801\u6587\u4ef6

    \u9664\u4e86\u672c\u5730\u8fd0\u884c\u4ee3\u7801\uff0c\u7f51\u9875\u7248\u8fd8\u652f\u6301 Python \u4ee3\u7801\u7684\u53ef\u89c6\u5316\u8fd0\u884c\uff08\u57fa\u4e8e pythontutor \u5b9e\u73b0\uff09\u3002\u5982\u56fe 0-6 \u6240\u793a\uff0c\u4f60\u53ef\u4ee5\u70b9\u51fb\u4ee3\u7801\u5757\u4e0b\u65b9\u7684\u201c\u53ef\u89c6\u5316\u8fd0\u884c\u201d\u6765\u5c55\u5f00\u89c6\u56fe\uff0c\u89c2\u5bdf\u7b97\u6cd5\u4ee3\u7801\u7684\u6267\u884c\u8fc7\u7a0b\uff1b\u4e5f\u53ef\u4ee5\u70b9\u51fb\u201c\u5168\u5c4f\u89c2\u770b\u201d\uff0c\u4ee5\u83b7\u5f97\u66f4\u597d\u7684\u9605\u89c8\u4f53\u9a8c\u3002

    \u56fe 0-6 \u00a0 Python \u4ee3\u7801\u7684\u53ef\u89c6\u5316\u8fd0\u884c

    "},{"location":"chapter_preface/suggestions/#024","title":"0.2.4 \u00a0 \u5728\u63d0\u95ee\u8ba8\u8bba\u4e2d\u5171\u540c\u6210\u957f","text":"

    \u5728\u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u8bf7\u4e0d\u8981\u8f7b\u6613\u8df3\u8fc7\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\u5c0f\u4f19\u4f34\u4eec\u5c06\u7aed\u8bda\u4e3a\u4f60\u89e3\u7b54\uff0c\u4e00\u822c\u60c5\u51b5\u4e0b\u53ef\u5728\u4e24\u5929\u5185\u56de\u590d\u3002

    \u5982\u56fe 0-7 \u6240\u793a\uff0c\u7f51\u9875\u7248\u6bcf\u4e2a\u7ae0\u8282\u7684\u5e95\u90e8\u90fd\u914d\u6709\u8bc4\u8bba\u533a\u3002\u5e0c\u671b\u4f60\u80fd\u591a\u5173\u6ce8\u8bc4\u8bba\u533a\u7684\u5185\u5bb9\u3002\u4e00\u65b9\u9762\uff0c\u4f60\u53ef\u4ee5\u4e86\u89e3\u5927\u5bb6\u9047\u5230\u7684\u95ee\u9898\uff0c\u4ece\u800c\u67e5\u6f0f\u8865\u7f3a\uff0c\u6fc0\u53d1\u66f4\u6df1\u5165\u7684\u601d\u8003\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u671f\u5f85\u4f60\u80fd\u6177\u6168\u5730\u56de\u7b54\u5176\u4ed6\u5c0f\u4f19\u4f34\u7684\u95ee\u9898\uff0c\u5206\u4eab\u4f60\u7684\u89c1\u89e3\uff0c\u5e2e\u52a9\u4ed6\u4eba\u8fdb\u6b65\u3002

    \u56fe 0-7 \u00a0 \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\u3002

    1. \u9636\u6bb5\u4e00\uff1a\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\u7684\u5185\u5bb9\u3002
    2. \u9636\u6bb5\u4e8c\uff1a\u5237\u7b97\u6cd5\u9898\u3002\u5efa\u8bae\u4ece\u70ed\u95e8\u9898\u76ee\u5f00\u5237\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\uff5e5 \u8f6e\u7684\u91cd\u590d\u540e\uff0c\u5c31\u80fd\u5c06\u5176\u7262\u8bb0\u5728\u5fc3\u3002\u63a8\u8350\u7684\u9898\u5355\u548c\u5237\u9898\u8ba1\u5212\u8bf7\u89c1\u6b64 GitHub \u4ed3\u5e93\u3002
    3. \u9636\u6bb5\u4e09\uff1a\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

    \u5982\u56fe 0-8 \u6240\u793a\uff0c\u672c\u4e66\u5185\u5bb9\u4e3b\u8981\u6db5\u76d6\u201c\u9636\u6bb5\u4e00\u201d\uff0c\u65e8\u5728\u5e2e\u52a9\u4f60\u66f4\u9ad8\u6548\u5730\u5c55\u5f00\u9636\u6bb5\u4e8c\u548c\u9636\u6bb5\u4e09\u7684\u5b66\u4e60\u3002

    \u56fe 0-8 \u00a0 \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\u4f60\u5df2\u6709\u4e00\u5b9a\u57fa\u7840\uff0c\u672c\u4e66\u80fd\u5e2e\u52a9\u4f60\u7cfb\u7edf\u56de\u987e\u7b97\u6cd5\u77e5\u8bc6\uff0c\u4e66\u4e2d\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\u548c\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\u81f3\u5173\u91cd\u8981\uff0c\u53ef\u4ee5\u5c11\u8d70\u8bb8\u591a\u5f2f\u8def\u3002
    • \u4e66\u4e2d\u7684\u52a8\u753b\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\u4ee3\u7801\u3002
    • \u672c\u4e66\u7f51\u9875\u7248\u7684\u6bcf\u4e2a\u7ae0\u8282\u90fd\u8bbe\u6709\u8bc4\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] Robert Sedgewick, et al. Algorithms (4th Edition).

    [4] \u4e25\u851a\u654f. \u6570\u636e\u7ed3\u6784\uff08C \u8bed\u8a00\u7248\uff09.

    [5] \u9093\u4fca\u8f89. \u6570\u636e\u7ed3\u6784\uff08C++ \u8bed\u8a00\u7248\uff0c\u7b2c\u4e09\u7248\uff09.

    [6] \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.

    [7] \u7a0b\u6770. \u5927\u8bdd\u6570\u636e\u7ed3\u6784.

    [8] \u738b\u4e89. \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u4e4b\u7f8e.

    [9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6th Edition).

    [10] Aston Zhang, et al. Dive into Deep Learning.

    "},{"location":"chapter_searching/","title":"\u7b2c 10 \u7ae0 \u00a0 \u641c\u7d22","text":"

    Abstract

    \u641c\u7d22\u662f\u4e00\u573a\u672a\u77e5\u7684\u5192\u9669\uff0c\u6211\u4eec\u6216\u8bb8\u9700\u8981\u8d70\u904d\u795e\u79d8\u7a7a\u95f4\u7684\u6bcf\u4e2a\u89d2\u843d\uff0c\u53c8\u6216\u8bb8\u53ef\u4ee5\u5feb\u901f\u9501\u5b9a\u76ee\u6807\u3002

    \u5728\u8fd9\u573a\u5bfb\u89c5\u4e4b\u65c5\u4e2d\uff0c\u6bcf\u4e00\u6b21\u63a2\u7d22\u90fd\u53ef\u80fd\u5f97\u5230\u4e00\u4e2a\u672a\u66fe\u6599\u60f3\u7684\u7b54\u6848\u3002

    "},{"location":"chapter_searching/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 10.1 \u00a0 \u4e8c\u5206\u67e5\u627e
    • 10.2 \u00a0 \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9
    • 10.3 \u00a0 \u4e8c\u5206\u67e5\u627e\u8fb9\u754c
    • 10.4 \u00a0 \u54c8\u5e0c\u4f18\u5316\u7b56\u7565
    • 10.5 \u00a0 \u91cd\u8bc6\u641c\u7d22\u7b97\u6cd5
    • 10.6 \u00a0 \u5c0f\u7ed3
    "},{"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\u7b56\u7565\u7684\u9ad8\u6548\u641c\u7d22\u7b97\u6cd5\u3002\u5b83\u5229\u7528\u6570\u636e\u7684\u6709\u5e8f\u6027\uff0c\u6bcf\u8f6e\u7f29\u5c0f\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\u4e14\u4e0d\u91cd\u590d\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\u793a\u4f8b\u5982\u56fe 10-1 \u6240\u793a\u3002

    \u56fe 10-1 \u00a0 \u4e8c\u5206\u67e5\u627e\u793a\u4f8b\u6570\u636e

    \u5982\u56fe 10-2 \u6240\u793a\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\u8bf7\u6ce8\u610f\uff0c\u4e2d\u62ec\u53f7\u8868\u793a\u95ed\u533a\u95f4\uff0c\u5176\u5305\u542b\u8fb9\u754c\u503c\u672c\u8eab\u3002

    \u63a5\u4e0b\u6765\uff0c\u5faa\u73af\u6267\u884c\u4ee5\u4e0b\u4e24\u6b65\u3002

    1. \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) \uff0c\u5176\u4e2d \\(\\lfloor \\: \\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\u4ee5\u4e0b\u4e09\u79cd\u60c5\u51b5\u3002
      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\\) \u3002
      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\\) \u3002
      3. \u5f53 nums[m] = target \u65f6\uff0c\u8bf4\u660e\u627e\u5230 target \uff0c\u56e0\u6b64\u8fd4\u56de\u7d22\u5f15 \\(m\\) \u3002

    \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

    <1><2><3><4><5><6><7>

    \u56fe 10-2 \u00a0 \u4e8c\u5206\u67e5\u627e\u6d41\u7a0b

    \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

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    i, 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\n    while 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\u987b\u8003\u8651\u5927\u6570\u8d8a\u754c\u95ee\u9898\n        m = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target:\n            i = m + 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        elif nums[m] > target:\n            j = m - 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        else:\n            return m  # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n    return -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\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\n    int 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\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    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\n    int 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\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -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\n    int 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\n    while (i <= j) {\n        int m = i + (j - i) / 2;   // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else                       // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\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\n    i, 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\n    for i <= j {\n        m := i + (j-i)/2      // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        } else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        } else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -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\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\n    while i <= j {\n        let m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        } else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        } else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -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\n    let i = 0,\n        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\n    while (i <= j) {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m \uff0c\u4f7f\u7528 parseInt() \u5411\u4e0b\u53d6\u6574\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] < target)\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target)\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else 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\n    return -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\n    let i = 0,\n        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\n    while (i <= j) {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] < target) {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        } else if (nums[m] > target) {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n        }\n    }\n    return -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -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\n  int 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\n  while (i <= j) {\n    int m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    if (nums[m] < target) {\n      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n      i = m + 1;\n    } else if (nums[m] > target) {\n      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n      j = m - 1;\n    } else {\n      // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n      return m;\n    }\n  }\n  // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n  return -1;\n}\n
    binary_search.rs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfn binary_search(nums: &[i32], target: i32) -> i32 {\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\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\n    while i <= j {\n        let m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m as usize] < target {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        } else if nums[m as usize] > target {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -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\n    int 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\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.kt
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfun binarySearch(nums: IntArray, 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\n    var i = 0\n    var 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\n    while (i <= j) {\n        val m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        else  // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1\n}\n
    binary_search.rb
    [class]{}-[func]{binary_search}\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\n    var i: usize = 0;\n    var 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\n    while (i <= j) {\n        var m = i + (j - i) / 2;                // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums.items[m] < target) {           // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        } else if (nums.items[m] > target) {    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        } else {                                // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return @intCast(m);\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \uff1a\u5728\u4e8c\u5206\u5faa\u73af\u4e2d\uff0c\u533a\u95f4\u6bcf\u8f6e\u7f29\u5c0f\u4e00\u534a\uff0c\u56e0\u6b64\u5faa\u73af\u6b21\u6570\u4e3a \\(\\log_2 n\\) \u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff1a\u6307\u9488 \\(i\\) \u548c \\(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\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search.py
    def binary_search_lcro(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09\"\"\"\n    # \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    i, 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\n    while i < j:\n        m = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target:\n            i = m + 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n        elif nums[m] > target:\n            j = m  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n        else:\n            return m  # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n    return -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n
    binary_search.cpp
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint binarySearchLCRO(vector<int> &nums, int target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    int 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\n    while (i < j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.java
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint binarySearchLCRO(int[] nums, int target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    int 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\n    while (i < j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.cs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint BinarySearchLCRO(int[] nums, int target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    int 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\n    while (i < j) {\n        int m = i + (j - i) / 2;   // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        else                       // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.go
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    i, 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\n    for i < j {\n        m := i + (j-i)/2      // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1\n        } else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m\n        } else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1\n}\n
    binary_search.swift
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfunc binarySearchLCRO(nums: [Int], target: Int) -> Int {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\n    while i < j {\n        let m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1\n        } else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m\n        } else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1\n}\n
    binary_search.js
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfunction binarySearchLCRO(nums, target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    let i = 0,\n        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\n    while (i < j) {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m \uff0c\u4f7f\u7528 parseInt() \u5411\u4e0b\u53d6\u6574\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] < target)\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target)\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        else return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.ts
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    let i = 0,\n        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\n    while (i < j) {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] < target) {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        } else if (nums[m] > target) {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n        }\n    }\n    return -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -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\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n  int 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\n  while (i < j) {\n    int m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    if (nums[m] < target) {\n      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n      i = m + 1;\n    } else if (nums[m] > target) {\n      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n      j = m;\n    } else {\n      // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n      return m;\n    }\n  }\n  // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n  return -1;\n}\n
    binary_search.rs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfn binary_search_lcro(nums: &[i32], target: i32) -> i32 {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\n    while i < j {\n        let m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m as usize] < target {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        } else if nums[m as usize] > target {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.c
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    int 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\n    while (i < j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.kt
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    var i = 0\n    var 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\n    while (i < j) {\n        val m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m\n        else  // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1\n}\n
    binary_search.rb
    [class]{}-[func]{binary_search_lcro}\n
    binary_search.zig
    // \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09\nfn binarySearchLCRO(comptime T: type, nums: std.ArrayList(T), target: T) T {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    var i: usize = 0;\n    var 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\n    while (i <= j) {\n        var m = i + (j - i) / 2;                // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums.items[m] < target) {           // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        } else if (nums.items[m] > target) {    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        } else {                                // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return @intCast(m);\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 10-3 \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

    \u7531\u4e8e\u201c\u53cc\u95ed\u533a\u95f4\u201d\u8868\u793a\u4e2d\u7684\u5de6\u53f3\u8fb9\u754c\u90fd\u88ab\u5b9a\u4e49\u4e3a\u95ed\u533a\u95f4\uff0c\u56e0\u6b64\u901a\u8fc7\u6307\u9488 \\(i\\) \u548c\u6307\u9488 \\(j\\) \u7f29\u5c0f\u533a\u95f4\u7684\u64cd\u4f5c\u4e5f\u662f\u5bf9\u79f0\u7684\u3002\u8fd9\u6837\u66f4\u4e0d\u5bb9\u6613\u51fa\u9519\uff0c\u56e0\u6b64\u4e00\u822c\u5efa\u8bae\u91c7\u7528\u201c\u53cc\u95ed\u533a\u95f4\u201d\u7684\u5199\u6cd5\u3002

    \u56fe 10-3 \u00a0 \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\u3002

    • \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\u987b\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\u4e3b\u8981\u6709\u4ee5\u4e0b\u539f\u56e0\u3002

    • \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 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.3 \u00a0 \u4e8c\u5206\u67e5\u627e\u8fb9\u754c","text":""},{"location":"chapter_searching/binary_search_edge/#1031","title":"10.3.1 \u00a0 \u67e5\u627e\u5de6\u8fb9\u754c","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6709\u5e8f\u6570\u7ec4 nums \uff0c\u5176\u4e2d\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\u3002\u8bf7\u8fd4\u56de\u6570\u7ec4\u4e2d\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 target \u7684\u7d22\u5f15\u3002\u82e5\u6570\u7ec4\u4e2d\u4e0d\u5305\u542b\u8be5\u5143\u7d20\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002

    \u56de\u5fc6\u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\u7684\u65b9\u6cd5\uff0c\u641c\u7d22\u5b8c\u6210\u540e \\(i\\) \u6307\u5411\u6700\u5de6\u4e00\u4e2a target \uff0c\u56e0\u6b64\u67e5\u627e\u63d2\u5165\u70b9\u672c\u8d28\u4e0a\u662f\u5728\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target \u7684\u7d22\u5f15\u3002

    \u8003\u8651\u901a\u8fc7\u67e5\u627e\u63d2\u5165\u70b9\u7684\u51fd\u6570\u5b9e\u73b0\u67e5\u627e\u5de6\u8fb9\u754c\u3002\u8bf7\u6ce8\u610f\uff0c\u6570\u7ec4\u4e2d\u53ef\u80fd\u4e0d\u5305\u542b target \uff0c\u8fd9\u79cd\u60c5\u51b5\u53ef\u80fd\u5bfc\u81f4\u4ee5\u4e0b\u4e24\u79cd\u7ed3\u679c\u3002

    • \u63d2\u5165\u70b9\u7684\u7d22\u5f15 \\(i\\) \u8d8a\u754c\u3002
    • \u5143\u7d20 nums[i] \u4e0e target \u4e0d\u76f8\u7b49\u3002

    \u5f53\u9047\u5230\u4ee5\u4e0a\u4e24\u79cd\u60c5\u51b5\u65f6\uff0c\u76f4\u63a5\u8fd4\u56de \\(-1\\) \u5373\u53ef\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_edge.py
    def binary_search_left_edge(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target\"\"\"\n    # \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    i = binary_search_insertion(nums, target)\n    # \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i\n
    binary_search_edge.cpp
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint binarySearchLeftEdge(vector<int> &nums, int target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    int i = binarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.java
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.cs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.go
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    i := binarySearchInsertion(nums, target)\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i\n}\n
    binary_search_edge.swift
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -> Int {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i\n}\n
    binary_search_edge.js
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfunction binarySearchLeftEdge(nums, target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    const i = binarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.ts
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfunction binarySearchLeftEdge(nums: Array<number>, target: number): number {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    const i = binarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.dart
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint binarySearchLeftEdge(List<int> nums, int target) {\n  // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n  int i = binarySearchInsertion(nums, target);\n  // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n  return i;\n}\n
    binary_search_edge.rs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfn binary_search_left_edge(nums: &[i32], target: i32) -> i32 {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    let i = binary_search_insertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    i\n}\n
    binary_search_edge.c
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    int i = binarySearchInsertion(nums, numSize, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.kt
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    val i = binarySearchInsertion(nums, target)\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i\n}\n
    binary_search_edge.rb
    [class]{}-[func]{binary_search_left_edge}\n
    binary_search_edge.zig
    [class]{}-[func]{binarySearchLeftEdge}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_searching/binary_search_edge/#1032","title":"10.3.2 \u00a0 \u67e5\u627e\u53f3\u8fb9\u754c","text":"

    \u90a3\u4e48\u5982\u4f55\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target \u5462\uff1f\u6700\u76f4\u63a5\u7684\u65b9\u5f0f\u662f\u4fee\u6539\u4ee3\u7801\uff0c\u66ff\u6362\u5728 nums[m] == target \u60c5\u51b5\u4e0b\u7684\u6307\u9488\u6536\u7f29\u64cd\u4f5c\u3002\u4ee3\u7801\u5728\u6b64\u7701\u7565\uff0c\u6709\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u3002

    \u4e0b\u9762\u6211\u4eec\u4ecb\u7ecd\u4e24\u79cd\u66f4\u52a0\u53d6\u5de7\u7684\u65b9\u6cd5\u3002

    "},{"location":"chapter_searching/binary_search_edge/#1","title":"1. \u00a0 \u590d\u7528\u67e5\u627e\u5de6\u8fb9\u754c","text":"

    \u5b9e\u9645\u4e0a\uff0c\u6211\u4eec\u53ef\u4ee5\u5229\u7528\u67e5\u627e\u6700\u5de6\u5143\u7d20\u7684\u51fd\u6570\u6765\u67e5\u627e\u6700\u53f3\u5143\u7d20\uff0c\u5177\u4f53\u65b9\u6cd5\u4e3a\uff1a\u5c06\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\u3002

    \u5982\u56fe 10-7 \u6240\u793a\uff0c\u67e5\u627e\u5b8c\u6210\u540e\uff0c\u6307\u9488 \\(i\\) \u6307\u5411\u6700\u5de6\u4e00\u4e2a target + 1\uff08\u5982\u679c\u5b58\u5728\uff09\uff0c\u800c \\(j\\) \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0c\u56e0\u6b64\u8fd4\u56de \\(j\\) \u5373\u53ef\u3002

    \u56fe 10-7 \u00a0 \u5c06\u67e5\u627e\u53f3\u8fb9\u754c\u8f6c\u5316\u4e3a\u67e5\u627e\u5de6\u8fb9\u754c

    \u8bf7\u6ce8\u610f\uff0c\u8fd4\u56de\u7684\u63d2\u5165\u70b9\u662f \\(i\\) \uff0c\u56e0\u6b64\u9700\u8981\u5c06\u5176\u51cf \\(1\\) \uff0c\u4ece\u800c\u83b7\u5f97 \\(j\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_edge.py
    def binary_search_right_edge(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target\"\"\"\n    # \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    i = binary_search_insertion(nums, target + 1)\n    # j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    j = i - 1\n    # \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if j == -1 or nums[j] != target:\n        return -1\n    # \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j\n
    binary_search_edge.cpp
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint binarySearchRightEdge(vector<int> &nums, int target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    int i = binarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    int j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.java
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint binarySearchRightEdge(int[] nums, int target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    int j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.cs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    int j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.go
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    i := binarySearchInsertion(nums, target+1)\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    j := i - 1\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j\n}\n
    binary_search_edge.swift
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -> Int {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    let j = i - 1\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j\n}\n
    binary_search_edge.js
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfunction binarySearchRightEdge(nums, target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    const j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.ts
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfunction binarySearchRightEdge(nums: Array<number>, target: number): number {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    const j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.dart
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint binarySearchRightEdge(List<int> nums, int target) {\n  // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n  int i = binarySearchInsertion(nums, target + 1);\n  // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n  int j = i - 1;\n  // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n  return j;\n}\n
    binary_search_edge.rs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfn binary_search_right_edge(nums: &[i32], target: i32) -> i32 {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    let i = binary_search_insertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    let j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    j\n}\n
    binary_search_edge.c
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    int j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.kt
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    val i = binarySearchInsertion(nums, target + 1)\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    val j = i - 1\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j\n}\n
    binary_search_edge.rb
    [class]{}-[func]{binary_search_right_edge}\n
    binary_search_edge.zig
    [class]{}-[func]{binarySearchRightEdge}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_searching/binary_search_edge/#2","title":"2. \u00a0 \u8f6c\u5316\u4e3a\u67e5\u627e\u5143\u7d20","text":"

    \u6211\u4eec\u77e5\u9053\uff0c\u5f53\u6570\u7ec4\u4e0d\u5305\u542b target \u65f6\uff0c\u6700\u7ec8 \\(i\\) \u548c \\(j\\) \u4f1a\u5206\u522b\u6307\u5411\u9996\u4e2a\u5927\u4e8e\u3001\u5c0f\u4e8e target \u7684\u5143\u7d20\u3002

    \u56e0\u6b64\uff0c\u5982\u56fe 10-8 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u6784\u9020\u4e00\u4e2a\u6570\u7ec4\u4e2d\u4e0d\u5b58\u5728\u7684\u5143\u7d20\uff0c\u7528\u4e8e\u67e5\u627e\u5de6\u53f3\u8fb9\u754c\u3002

    • \u67e5\u627e\u6700\u5de6\u4e00\u4e2a target \uff1a\u53ef\u4ee5\u8f6c\u5316\u4e3a\u67e5\u627e target - 0.5 \uff0c\u5e76\u8fd4\u56de\u6307\u9488 \\(i\\) \u3002
    • \u67e5\u627e\u6700\u53f3\u4e00\u4e2a target \uff1a\u53ef\u4ee5\u8f6c\u5316\u4e3a\u67e5\u627e target + 0.5 \uff0c\u5e76\u8fd4\u56de\u6307\u9488 \\(j\\) \u3002

    \u56fe 10-8 \u00a0 \u5c06\u67e5\u627e\u8fb9\u754c\u8f6c\u5316\u4e3a\u67e5\u627e\u5143\u7d20

    \u4ee3\u7801\u5728\u6b64\u7701\u7565\uff0c\u4ee5\u4e0b\u4e24\u70b9\u503c\u5f97\u6ce8\u610f\u3002

    • \u7ed9\u5b9a\u6570\u7ec4\u4e0d\u5305\u542b\u5c0f\u6570\uff0c\u8fd9\u610f\u5473\u7740\u6211\u4eec\u65e0\u987b\u5173\u5fc3\u5982\u4f55\u5904\u7406\u76f8\u7b49\u7684\u60c5\u51b5\u3002
    • \u56e0\u4e3a\u8be5\u65b9\u6cd5\u5f15\u5165\u4e86\u5c0f\u6570\uff0c\u6240\u4ee5\u9700\u8981\u5c06\u51fd\u6570\u4e2d\u7684\u53d8\u91cf target \u6539\u4e3a\u6d6e\u70b9\u6570\u7c7b\u578b\uff08Python \u65e0\u987b\u6539\u52a8\uff09\u3002
    "},{"location":"chapter_searching/binary_search_insertion/","title":"10.2 \u00a0 \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9","text":"

    \u4e8c\u5206\u67e5\u627e\u4e0d\u4ec5\u53ef\u7528\u4e8e\u641c\u7d22\u76ee\u6807\u5143\u7d20\uff0c\u8fd8\u53ef\u7528\u4e8e\u89e3\u51b3\u8bb8\u591a\u53d8\u79cd\u95ee\u9898\uff0c\u6bd4\u5982\u641c\u7d22\u76ee\u6807\u5143\u7d20\u7684\u63d2\u5165\u4f4d\u7f6e\u3002

    "},{"location":"chapter_searching/binary_search_insertion/#1021","title":"10.2.1 \u00a0 \u65e0\u91cd\u590d\u5143\u7d20\u7684\u60c5\u51b5","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6709\u5e8f\u6570\u7ec4 nums \u548c\u4e00\u4e2a\u5143\u7d20 target \uff0c\u6570\u7ec4\u4e0d\u5b58\u5728\u91cd\u590d\u5143\u7d20\u3002\u73b0\u5c06 target \u63d2\u5165\u6570\u7ec4 nums \u4e2d\uff0c\u5e76\u4fdd\u6301\u5176\u6709\u5e8f\u6027\u3002\u82e5\u6570\u7ec4\u4e2d\u5df2\u5b58\u5728\u5143\u7d20 target \uff0c\u5219\u63d2\u5165\u5230\u5176\u5de6\u65b9\u3002\u8bf7\u8fd4\u56de\u63d2\u5165\u540e target \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15\u3002\u793a\u4f8b\u5982\u56fe 10-4 \u6240\u793a\u3002

    \u56fe 10-4 \u00a0 \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\u793a\u4f8b\u6570\u636e

    \u5982\u679c\u60f3\u590d\u7528\u4e0a\u4e00\u8282\u7684\u4e8c\u5206\u67e5\u627e\u4ee3\u7801\uff0c\u5219\u9700\u8981\u56de\u7b54\u4ee5\u4e0b\u4e24\u4e2a\u95ee\u9898\u3002

    \u95ee\u9898\u4e00\uff1a\u5f53\u6570\u7ec4\u4e2d\u5305\u542b target \u65f6\uff0c\u63d2\u5165\u70b9\u7684\u7d22\u5f15\u662f\u5426\u662f\u8be5\u5143\u7d20\u7684\u7d22\u5f15\uff1f

    \u9898\u76ee\u8981\u6c42\u5c06 target \u63d2\u5165\u5230\u76f8\u7b49\u5143\u7d20\u7684\u5de6\u8fb9\uff0c\u8fd9\u610f\u5473\u7740\u65b0\u63d2\u5165\u7684 target \u66ff\u6362\u4e86\u539f\u6765 target \u7684\u4f4d\u7f6e\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u5f53\u6570\u7ec4\u5305\u542b target \u65f6\uff0c\u63d2\u5165\u70b9\u7684\u7d22\u5f15\u5c31\u662f\u8be5 target \u7684\u7d22\u5f15\u3002

    \u95ee\u9898\u4e8c\uff1a\u5f53\u6570\u7ec4\u4e2d\u4e0d\u5b58\u5728 target \u65f6\uff0c\u63d2\u5165\u70b9\u662f\u54ea\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\uff1f

    \u8fdb\u4e00\u6b65\u601d\u8003\u4e8c\u5206\u67e5\u627e\u8fc7\u7a0b\uff1a\u5f53 nums[m] < target \u65f6 \\(i\\) \u79fb\u52a8\uff0c\u8fd9\u610f\u5473\u7740\u6307\u9488 \\(i\\) \u5728\u5411\u5927\u4e8e\u7b49\u4e8e target \u7684\u5143\u7d20\u9760\u8fd1\u3002\u540c\u7406\uff0c\u6307\u9488 \\(j\\) \u59cb\u7ec8\u5728\u5411\u5c0f\u4e8e\u7b49\u4e8e target \u7684\u5143\u7d20\u9760\u8fd1\u3002

    \u56e0\u6b64\u4e8c\u5206\u7ed3\u675f\u65f6\u4e00\u5b9a\u6709\uff1a\\(i\\) \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\uff0c\\(j\\) \u6307\u5411\u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u3002\u6613\u5f97\u5f53\u6570\u7ec4\u4e0d\u5305\u542b target \u65f6\uff0c\u63d2\u5165\u7d22\u5f15\u4e3a \\(i\\) \u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_insertion.py
    def binary_search_insertion_simple(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09\"\"\"\n    i, j = 0, len(nums) - 1  # \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while i <= j:\n        m = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target:\n            i = m + 1  # target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        elif nums[m] > target:\n            j = m - 1  # target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        else:\n            return m  # \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n    # \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n
    binary_search_insertion.cpp
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertionSimple(vector<int> &nums, int target) {\n    int i = 0, j = nums.size() - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.java
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.cs
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.go
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    i, j := 0, len(nums)-1\n    for i <= j {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        m := i + (j-i)/2\n        if nums[m] < target {\n            // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        } else if nums[m] > target {\n            // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        } else {\n            // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n            return m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.swift
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -> Int {\n    // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i <= j {\n        let m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target {\n            i = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if nums[m] > target {\n            j = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.js
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        const m = Math.floor(i + (j - i) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m, \u4f7f\u7528 Math.floor() \u5411\u4e0b\u53d6\u6574\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.ts
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfunction binarySearchInsertionSimple(\n    nums: Array<number>,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        const m = Math.floor(i + (j - i) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m, \u4f7f\u7528 Math.floor() \u5411\u4e0b\u53d6\u6574\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.dart
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertionSimple(List<int> nums, int target) {\n  int i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n  while (i <= j) {\n    int m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    if (nums[m] < target) {\n      i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n    } else if (nums[m] > target) {\n      j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n    } else {\n      return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n    }\n  }\n  // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n  return i;\n}\n
    binary_search_insertion.rs
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfn binary_search_insertion_simple(nums: &[i32], target: i32) -> i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while i <= j {\n        let m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m as usize] < target {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if nums[m as usize] > target {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m;\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    i\n}\n
    binary_search_insertion.c
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.kt
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        val m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.rb
    [class]{}-[func]{binary_search_insertion_simple}\n
    binary_search_insertion.zig
    [class]{}-[func]{binarySearchInsertionSimple}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_searching/binary_search_insertion/#1022","title":"10.2.2 \u00a0 \u5b58\u5728\u91cd\u590d\u5143\u7d20\u7684\u60c5\u51b5","text":"

    Question

    \u5728\u4e0a\u4e00\u9898\u7684\u57fa\u7840\u4e0a\uff0c\u89c4\u5b9a\u6570\u7ec4\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u5176\u4f59\u4e0d\u53d8\u3002

    \u5047\u8bbe\u6570\u7ec4\u4e2d\u5b58\u5728\u591a\u4e2a target \uff0c\u5219\u666e\u901a\u4e8c\u5206\u67e5\u627e\u53ea\u80fd\u8fd4\u56de\u5176\u4e2d\u4e00\u4e2a target \u7684\u7d22\u5f15\uff0c\u800c\u65e0\u6cd5\u786e\u5b9a\u8be5\u5143\u7d20\u7684\u5de6\u8fb9\u548c\u53f3\u8fb9\u8fd8\u6709\u591a\u5c11 target\u3002

    \u9898\u76ee\u8981\u6c42\u5c06\u76ee\u6807\u5143\u7d20\u63d2\u5165\u5230\u6700\u5de6\u8fb9\uff0c\u6240\u4ee5\u6211\u4eec\u9700\u8981\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5de6\u4e00\u4e2a target \u7684\u7d22\u5f15\u3002\u521d\u6b65\u8003\u8651\u901a\u8fc7\u56fe 10-5 \u6240\u793a\u7684\u6b65\u9aa4\u5b9e\u73b0\u3002

    1. \u6267\u884c\u4e8c\u5206\u67e5\u627e\uff0c\u5f97\u5230\u4efb\u610f\u4e00\u4e2a target \u7684\u7d22\u5f15\uff0c\u8bb0\u4e3a \\(k\\) \u3002
    2. \u4ece\u7d22\u5f15 \\(k\\) \u5f00\u59cb\uff0c\u5411\u5de6\u8fdb\u884c\u7ebf\u6027\u904d\u5386\uff0c\u5f53\u627e\u5230\u6700\u5de6\u8fb9\u7684 target \u65f6\u8fd4\u56de\u3002

    \u56fe 10-5 \u00a0 \u7ebf\u6027\u67e5\u627e\u91cd\u590d\u5143\u7d20\u7684\u63d2\u5165\u70b9

    \u6b64\u65b9\u6cd5\u867d\u7136\u53ef\u7528\uff0c\u4f46\u5176\u5305\u542b\u7ebf\u6027\u67e5\u627e\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002\u5f53\u6570\u7ec4\u4e2d\u5b58\u5728\u5f88\u591a\u91cd\u590d\u7684 target \u65f6\uff0c\u8be5\u65b9\u6cd5\u6548\u7387\u5f88\u4f4e\u3002

    \u73b0\u8003\u8651\u62d3\u5c55\u4e8c\u5206\u67e5\u627e\u4ee3\u7801\u3002\u5982\u56fe 10-6 \u6240\u793a\uff0c\u6574\u4f53\u6d41\u7a0b\u4fdd\u6301\u4e0d\u53d8\uff0c\u6bcf\u8f6e\u5148\u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 \\(m\\) \uff0c\u518d\u5224\u65ad target \u548c nums[m] \u7684\u5927\u5c0f\u5173\u7cfb\uff0c\u5206\u4e3a\u4ee5\u4e0b\u51e0\u79cd\u60c5\u51b5\u3002

    • \u5f53 nums[m] < target \u6216 nums[m] > target \u65f6\uff0c\u8bf4\u660e\u8fd8\u6ca1\u6709\u627e\u5230 target \uff0c\u56e0\u6b64\u91c7\u7528\u666e\u901a\u4e8c\u5206\u67e5\u627e\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\u5c0f\u4e8e target \u7684\u5143\u7d20\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

    \u5faa\u73af\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\u7d22\u5f15 \\(i\\) \u5c31\u662f\u63d2\u5165\u70b9\u3002

    <1><2><3><4><5><6><7><8>

    \u56fe 10-6 \u00a0 \u4e8c\u5206\u67e5\u627e\u91cd\u590d\u5143\u7d20\u7684\u63d2\u5165\u70b9\u7684\u6b65\u9aa4

    \u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff0c\u5224\u65ad\u5206\u652f nums[m] > target \u548c nums[m] == target \u7684\u64cd\u4f5c\u76f8\u540c\uff0c\u56e0\u6b64\u4e24\u8005\u53ef\u4ee5\u5408\u5e76\u3002

    \u5373\u4fbf\u5982\u6b64\uff0c\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u5c06\u5224\u65ad\u6761\u4ef6\u4fdd\u6301\u5c55\u5f00\uff0c\u56e0\u4e3a\u5176\u903b\u8f91\u66f4\u52a0\u6e05\u6670\u3001\u53ef\u8bfb\u6027\u66f4\u597d\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_insertion.py
    def binary_search_insertion(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09\"\"\"\n    i, j = 0, len(nums) - 1  # \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while i <= j:\n        m = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target:\n            i = m + 1  # target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        elif nums[m] > target:\n            j = m - 1  # target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        else:\n            j = m - 1  # \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n    # \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n
    binary_search_insertion.cpp
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertion(vector<int> &nums, int target) {\n    int i = 0, j = nums.size() - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.java
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.cs
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.go
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    i, j := 0, len(nums)-1\n    for i <= j {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        m := i + (j-i)/2\n        if nums[m] < target {\n            // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        } else if nums[m] > target {\n            // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        } else {\n            // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.swift
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfunc binarySearchInsertion(nums: [Int], target: Int) -> Int {\n    // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i <= j {\n        let m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target {\n            i = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if nums[m] > target {\n            j = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1 // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.js
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        const m = Math.floor(i + (j - i) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m, \u4f7f\u7528 Math.floor() \u5411\u4e0b\u53d6\u6574\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.ts
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfunction binarySearchInsertion(nums: Array<number>, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        const m = Math.floor(i + (j - i) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m, \u4f7f\u7528 Math.floor() \u5411\u4e0b\u53d6\u6574\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.dart
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertion(List<int> nums, int target) {\n  int i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n  while (i <= j) {\n    int m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    if (nums[m] < target) {\n      i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n    } else if (nums[m] > target) {\n      j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n    } else {\n      j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n    }\n  }\n  // \u8fd4\u56de\u63d2\u5165\u70b9 i\n  return i;\n}\n
    binary_search_insertion.rs
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\npub fn binary_search_insertion(nums: &[i32], target: i32) -> i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while i <= j {\n        let m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m as usize] < target {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if nums[m as usize] > target {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    i\n}\n
    binary_search_insertion.c
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.kt
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        val m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1 // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.rb
    [class]{}-[func]{binary_search_insertion}\n
    binary_search_insertion.zig
    [class]{}-[func]{binarySearchInsertion}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    Tip

    \u672c\u8282\u7684\u4ee3\u7801\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

    \u603b\u7684\u6765\u770b\uff0c\u4e8c\u5206\u67e5\u627e\u65e0\u975e\u5c31\u662f\u7ed9\u6307\u9488 \\(i\\) \u548c \\(j\\) \u5206\u522b\u8bbe\u5b9a\u641c\u7d22\u76ee\u6807\uff0c\u76ee\u6807\u53ef\u80fd\u662f\u4e00\u4e2a\u5177\u4f53\u7684\u5143\u7d20\uff08\u4f8b\u5982 target \uff09\uff0c\u4e5f\u53ef\u80fd\u662f\u4e00\u4e2a\u5143\u7d20\u8303\u56f4\uff08\u4f8b\u5982\u5c0f\u4e8e target \u7684\u5143\u7d20\uff09\u3002

    \u5728\u4e0d\u65ad\u7684\u5faa\u73af\u4e8c\u5206\u4e2d\uff0c\u6307\u9488 \\(i\\) \u548c \\(j\\) \u90fd\u9010\u6e10\u903c\u8fd1\u9884\u5148\u8bbe\u5b9a\u7684\u76ee\u6807\u3002\u6700\u7ec8\uff0c\u5b83\u4eec\u6216\u662f\u6210\u529f\u627e\u5230\u7b54\u6848\uff0c\u6216\u662f\u8d8a\u8fc7\u8fb9\u754c\u540e\u505c\u6b62\u3002

    "},{"location":"chapter_searching/replace_linear_by_hashing/","title":"10.4 \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/#1041","title":"10.4.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\u5982\u56fe 10-9 \u6240\u793a\uff0c\u6211\u4eec\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

    \u56fe 10-9 \u00a0 \u7ebf\u6027\u67e5\u627e\u6c42\u89e3\u4e24\u6570\u4e4b\u548c

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u4e3a O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n
    two_sum.cpp
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nvector<int> twoSumBruteForce(vector<int> &nums, int target) {\n    int size = nums.size();\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (int i = 0; i < size - 1; i++) {\n        for (int j = i + 1; j < size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n
    two_sum.java
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (int i = 0; i < size - 1; i++) {\n        for (int j = i + 1; j < size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n
    two_sum.cs
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (int i = 0; i < size - 1; i++) {\n        for (int j = i + 1; j < size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n
    two_sum.go
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for i := 0; i < size-1; i++ {\n        for j := i + 1; i < size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\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\u4e3a O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n
    two_sum.js
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (let i = 0; i < n; i++) {\n        for (let j = i + 1; j < n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n
    two_sum.ts
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (let i = 0; i < n; i++) {\n        for (let j = i + 1; j < n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n
    two_sum.dart
    /* \u65b9\u6cd5\u4e00\uff1a \u66b4\u529b\u679a\u4e3e */\nList<int> twoSumBruteForce(List<int> nums, int target) {\n  int size = nums.length;\n  // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n  for (var i = 0; i < size - 1; i++) {\n    for (var j = i + 1; j < size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n
    two_sum.rs
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\npub fn two_sum_brute_force(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {\n    let size = nums.len();\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n
    two_sum.c
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i < numsSize; ++i) {\n        for (int j = i + 1; j < numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n
    two_sum.kt
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (i in 0..<size - 1) {\n        for (j in i + 1..<size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n
    two_sum.rb
    [class]{}-[func]{two_sum_brute_force}\n
    two_sum.zig
    // \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e\nfn twoSumBruteForce(nums: []i32, target: i32) ?[2]i32 {\n    var size: usize = nums.len;\n    var i: usize = 0;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    while (i < size - 1) : (i += 1) {\n        var j = i + 1;\n        while (j < size) : (j += 1) {\n            if (nums[i] + nums[j] == target) {\n                return [_]i32{@intCast(i), @intCast(j)};\n            }\n        }\n    }\n    return null;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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/#1042","title":"10.4.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\u56fe 10-10 \u6240\u793a\u7684\u6b65\u9aa4\u3002

    1. \u5224\u65ad\u6570\u5b57 target - nums[i] \u662f\u5426\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u82e5\u662f\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u8fd9\u4e24\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\u3002
    2. \u5c06\u952e\u503c\u5bf9 nums[i] \u548c\u7d22\u5f15 i \u6dfb\u52a0\u8fdb\u54c8\u5e0c\u8868\u3002
    <1><2><3>

    \u56fe 10-10 \u00a0 \u8f85\u52a9\u54c8\u5e0c\u8868\u6c42\u89e3\u4e24\u6570\u4e4b\u548c

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff0c\u4ec5\u9700\u5355\u5c42\u5faa\u73af\u5373\u53ef\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u4e3a O(n)\n    dic = {}\n    # \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n
    two_sum.cpp
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nvector<int> twoSumHashTable(vector<int> &nums, int target) {\n    int size = nums.size();\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    unordered_map<int, int> dic;\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (int i = 0; i < size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n
    two_sum.java
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    Map<Integer, Integer> dic = new HashMap<>();\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (int i = 0; i < size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n
    two_sum.cs
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    Dictionary<int, int> dic = [];\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (int i = 0; i < size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\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\u4e3a O(n)\n    hashTable := map[int]int{}\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\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\u4e3a O(n)\n    var dic: [Int: Int] = [:]\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\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\u4e3a O(n)\n    let m = {};\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (let i = 0; i < nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\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\u4e3a O(n)\n    let m: Map<number, number> = new Map();\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (let i = 0; i < nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n
    two_sum.dart
    /* \u65b9\u6cd5\u4e8c\uff1a \u8f85\u52a9\u54c8\u5e0c\u8868 */\nList<int> twoSumHashTable(List<int> nums, int target) {\n  int size = nums.length;\n  // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n  Map<int, int> dic = HashMap();\n  // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n  for (var i = 0; i < size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () => i);\n  }\n  return [0];\n}\n
    two_sum.rs
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\npub fn two_sum_hash_table(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    let mut dic = HashMap::new();\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&(target - num)) {\n            Some(v) => return Some(vec![*v as i32, i as i32]),\n            None => dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n
    two_sum.c
    /* \u54c8\u5e0c\u8868 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n} HashTable;\n\n/* \u54c8\u5e0c\u8868\u67e5\u8be2 */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &key, tmp);\n    return tmp;\n}\n\n/* \u54c8\u5e0c\u8868\u5143\u7d20\u63d2\u5165 */\nvoid insert(HashTable *h, int key, int val) {\n    HashTable *t = find(h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp->key = key, tmp->val = val;\n        HASH_ADD_INT(h, key, tmp);\n    } else {\n        t->val = val;\n    }\n}\n\n/* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i < numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t->val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n
    two_sum.kt
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    val dic = HashMap<Int, Int>()\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (i in 0..<size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n
    two_sum.rb
    [class]{}-[func]{two_sum_hash_table}\n
    two_sum.zig
    // \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868\nfn twoSumHashTable(nums: []i32, target: i32) !?[2]i32 {\n    var size: usize = nums.len;\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);\n    defer dic.deinit();\n    var i: usize = 0;\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    while (i < size) : (i += 1) {\n        if (dic.contains(target - nums[i])) {\n            return [_]i32{dic.get(target - nums[i]).?, @intCast(i)};\n        }\n        try dic.put(nums[i], @intCast(i));\n    }\n    return null;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6b64\u65b9\u6cd5\u901a\u8fc7\u54c8\u5e0c\u67e5\u627e\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n^2)\\) \u964d\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.5 \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

    \u641c\u7d22\u7b97\u6cd5\u53ef\u6839\u636e\u5b9e\u73b0\u601d\u8def\u5206\u4e3a\u4ee5\u4e0b\u4e24\u7c7b\u3002

    • \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/#1051","title":"10.5.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

    • \u201c\u7ebf\u6027\u641c\u7d22\u201d\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
    • \u201c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u201d\u548c\u201c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u201d\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\u4ece\u521d\u59cb\u8282\u70b9\u5f00\u59cb\uff0c\u6cbf\u7740\u4e00\u6761\u8def\u5f84\u8d70\u5230\u5934\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\u987b\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/#1052","title":"10.5.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

    • \u201c\u4e8c\u5206\u67e5\u627e\u201d\u5229\u7528\u6570\u636e\u7684\u6709\u5e8f\u6027\u5b9e\u73b0\u9ad8\u6548\u67e5\u627e\uff0c\u4ec5\u9002\u7528\u4e8e\u6570\u7ec4\u3002
    • \u201c\u54c8\u5e0c\u67e5\u627e\u201d\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
    • \u201c\u6811\u67e5\u627e\u201d\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\u9500\u3002

    Tip

    \u81ea\u9002\u5e94\u641c\u7d22\u7b97\u6cd5\u5e38\u88ab\u79f0\u4e3a\u67e5\u627e\u7b97\u6cd5\uff0c\u4e3b\u8981\u7528\u4e8e\u5728\u7279\u5b9a\u6570\u636e\u7ed3\u6784\u4e2d\u5feb\u901f\u68c0\u7d22\u76ee\u6807\u5143\u7d20\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/#1053","title":"10.5.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\u4ece\u4e2d\u641c\u7d22\u76ee\u6807\u5143\u7d20\u3002\u5404\u4e2a\u65b9\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u5982\u56fe 10-11 \u6240\u793a\u3002

    \u56fe 10-11 \u00a0 \u591a\u79cd\u641c\u7d22\u7b56\u7565

    \u4e0a\u8ff0\u51e0\u79cd\u65b9\u6cd5\u7684\u64cd\u4f5c\u6548\u7387\u4e0e\u7279\u6027\u5982\u8868 10-1 \u6240\u793a\u3002

    \u8868 10-1 \u00a0 \u67e5\u627e\u7b97\u6cd5\u6548\u7387\u5bf9\u6bd4

    \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

    \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\u987b\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\u5206\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\u7684\u5f00\u9500\u3002
    "},{"location":"chapter_searching/summary/","title":"10.6 \u00a0 \u5c0f\u7ed3","text":"
    • \u4e8c\u5206\u67e5\u627e\u4f9d\u8d56\u6570\u636e\u7684\u6709\u5e8f\u6027\uff0c\u901a\u8fc7\u5faa\u73af\u9010\u6b65\u7f29\u51cf\u4e00\u534a\u641c\u7d22\u533a\u95f4\u6765\u8fdb\u884c\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\u987b\u5bf9\u6570\u636e\u8fdb\u884c\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\u7528\u4e8e\u5bf9\u67e5\u8be2\u6548\u7387\u8981\u6c42\u8f83\u9ad8\u4e14\u65e0\u987b\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\u81f3 \\(O(1)\\) \u3002
    "},{"location":"chapter_sorting/","title":"\u7b2c 11 \u7ae0 \u00a0 \u6392\u5e8f","text":"

    Abstract

    \u6392\u5e8f\u72b9\u5982\u4e00\u628a\u5c06\u6df7\u4e71\u53d8\u4e3a\u79e9\u5e8f\u7684\u9b54\u6cd5\u94a5\u5319\uff0c\u4f7f\u6211\u4eec\u80fd\u4ee5\u66f4\u9ad8\u6548\u7684\u65b9\u5f0f\u7406\u89e3\u4e0e\u5904\u7406\u6570\u636e\u3002

    \u65e0\u8bba\u662f\u7b80\u5355\u7684\u5347\u5e8f\uff0c\u8fd8\u662f\u590d\u6742\u7684\u5206\u7c7b\u6392\u5217\uff0c\u6392\u5e8f\u90fd\u5411\u6211\u4eec\u5c55\u793a\u4e86\u6570\u636e\u7684\u548c\u8c10\u7f8e\u611f\u3002

    "},{"location":"chapter_sorting/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 11.1 \u00a0 \u6392\u5e8f\u7b97\u6cd5
    • 11.2 \u00a0 \u9009\u62e9\u6392\u5e8f
    • 11.3 \u00a0 \u5192\u6ce1\u6392\u5e8f
    • 11.4 \u00a0 \u63d2\u5165\u6392\u5e8f
    • 11.5 \u00a0 \u5feb\u901f\u6392\u5e8f
    • 11.6 \u00a0 \u5f52\u5e76\u6392\u5e8f
    • 11.7 \u00a0 \u5806\u6392\u5e8f
    • 11.8 \u00a0 \u6876\u6392\u5e8f
    • 11.9 \u00a0 \u8ba1\u6570\u6392\u5e8f
    • 11.10 \u00a0 \u57fa\u6570\u6392\u5e8f
    • 11.11 \u00a0 \u5c0f\u7ed3
    "},{"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

    \u5982\u56fe 11-4 \u6240\u793a\uff0c\u5192\u6ce1\u8fc7\u7a0b\u53ef\u4ee5\u5229\u7528\u5143\u7d20\u4ea4\u6362\u64cd\u4f5c\u6765\u6a21\u62df\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\u4e8c\u8005\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>

    \u56fe 11-4 \u00a0 \u5229\u7528\u5143\u7d20\u4ea4\u6362\u64cd\u4f5c\u6a21\u62df\u5192\u6ce1

    "},{"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\u5982\u56fe 11-5 \u6240\u793a\u3002

    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\u3002
    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\u987b\u6392\u5e8f\uff0c\u56e0\u6b64\u6570\u7ec4\u6392\u5e8f\u5b8c\u6210\u3002

    \u56fe 11-5 \u00a0 \u5192\u6ce1\u6392\u5e8f\u6d41\u7a0b

    \u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig bubble_sort.py
    def bubble_sort(nums: list[int]):\n    \"\"\"\u5192\u6ce1\u6392\u5e8f\"\"\"\n    n = len(nums)\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j in range(i):\n            if nums[j] > nums[j + 1]:\n                # \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\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]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                // \u8fd9\u91cc\u4f7f\u7528\u4e86 std::swap() \u51fd\u6570\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n
    bubble_sort.java
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(int[] nums) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\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]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\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]\n    for 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\n        for j := 0; j < i; j++ {\n            if nums[j] > nums[j+1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\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]\n    for i in nums.indices.dropFirst().reversed() {\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\n        for j in 0 ..< i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums.swapAt(j, j + 1)\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]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[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]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[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]\n  for (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\n    for (int j = 0; j < i; j++) {\n      if (nums[j] > nums[j + 1]) {\n        // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n
    bubble_sort.rs
    /* \u5192\u6ce1\u6392\u5e8f */\nfn bubble_sort(nums: &mut [i32]) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in (1..nums.len()).rev() {\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\n        for j in 0..i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[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]\n    for (int i = 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n
    bubble_sort.kt
    /* \u5192\u6ce1\u6392\u5e8f */\nfun bubbleSort(nums: IntArray) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (i in nums.size - 1 downTo 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\n        for (j in 0..<i) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j] = nums[j+1].also { nums[j+1] = nums[j] }\n            }\n        }\n    }\n}\n
    bubble_sort.rb
    [class]{}-[func]{bubble_sort}\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]\n    var i: usize = nums.len - 1;\n    while (i > 0) : (i -= 1) {\n        var 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\n        while (j < i) : (j += 1) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                var tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u65f6\u95f4\u590d\u6742\u5ea6\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig bubble_sort.py
    def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"\u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09\"\"\"\n    n = len(nums)\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in range(n - 1, 0, -1):\n        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\n        for j in range(i):\n            if nums[j] > nums[j + 1]:\n                # \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n        if not flag:\n            break  # \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\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]\n    for (int i = nums.size() - 1; i > 0; i--) {\n        bool 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                // \u8fd9\u91cc\u4f7f\u7528\u4e86 std::swap() \u51fd\u6570\n                swap(nums[j], nums[j + 1]);\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag)\n            break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n    }\n}\n
    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]\n    for (int i = nums.length - 1; i > 0; i--) {\n        boolean 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag)\n            break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\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]\n    for (int i = nums.Length - 1; i > 0; i--) {\n        bool 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag) break;     // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n    }\n}\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]\n    for i := len(nums) - 1; i > 0; i-- {\n        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\n        for j := 0; j < i; j++ {\n            if nums[j] > nums[j+1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if flag == false { // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n            break\n        }\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]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n        for j in 0 ..< i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums.swapAt(j, j + 1)\n                flag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if !flag { // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n            break\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]\n    for (let i = nums.length - 1; i > 0; i--) {\n        let 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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag) break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\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]\n    for (let i = nums.length - 1; i > 0; i--) {\n        let 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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag) break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\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]\n  for (int i = nums.length - 1; i > 0; i--) {\n    bool 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\n    for (int j = 0; j < i; j++) {\n      if (nums[j] > nums[j + 1]) {\n        // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n      }\n    }\n    if (!flag) break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n  }\n}\n
    bubble_sort.rs
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09 */\nfn bubble_sort_with_flag(nums: &mut [i32]) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut 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\n        for j in 0..i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if !flag {\n            break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n        };\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]\n    for (int i = size - 1; i > 0; i--) {\n        bool 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n
    bubble_sort.kt
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09 */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var 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\n        for (j in 0..<i) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j] = nums[j + 1].also { nums[j] = nums[j + 1] }\n                flag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag) break // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n    }\n}\n
    bubble_sort.rb
    [class]{}-[func]{bubble_sort_with_flag}\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]\n    var i: usize = nums.len - 1;\n    while (i > 0) : (i -= 1) {\n        var flag = false;   // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n        var 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\n        while (j < i) : (j += 1) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                var tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true;\n            }\n        }\n        if (!flag) break;   // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\\)\u3001\\(n - 2\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \uff0c\u603b\u548c\u4e3a \\((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\\) \u548c \\(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\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\u9636\u3002

    \u300c\u6876\u6392\u5e8f bucket sort\u300d\u662f\u5206\u6cbb\u7b56\u7565\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\u5176\u5143\u7d20\u662f\u8303\u56f4 \\([0, 1)\\) \u5185\u7684\u6d6e\u70b9\u6570\u3002\u6876\u6392\u5e8f\u7684\u6d41\u7a0b\u5982\u56fe 11-13 \u6240\u793a\u3002

    1. \u521d\u59cb\u5316 \\(k\\) \u4e2a\u6876\uff0c\u5c06 \\(n\\) \u4e2a\u5143\u7d20\u5206\u914d\u5230 \\(k\\) \u4e2a\u6876\u4e2d\u3002
    2. \u5bf9\u6bcf\u4e2a\u6876\u5206\u522b\u6267\u884c\u6392\u5e8f\uff08\u8fd9\u91cc\u91c7\u7528\u7f16\u7a0b\u8bed\u8a00\u7684\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff09\u3002
    3. \u6309\u7167\u6876\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u5408\u5e76\u7ed3\u679c\u3002

    \u56fe 11-13 \u00a0 \u6876\u6392\u5e8f\u7b97\u6cd5\u6d41\u7a0b

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig bucket_sort.py
    def bucket_sort(nums: list[float]):\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\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for num in nums:\n        # \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        i = int(num * k)\n        # \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].append(num)\n    # 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for 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\n        bucket.sort()\n    # 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\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\n    int k = nums.size() / 2;\n    vector<vector<float>> buckets(k);\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (float num : nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        int i = num * k;\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 bucket_idx\n        buckets[i].push_back(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    int i = 0;\n    for (vector<float> &bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n
    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\n    int k = nums.length / 2;\n    List<List<Float>> buckets = new ArrayList<>();\n    for (int i = 0; i < k; i++) {\n        buckets.add(new ArrayList<>());\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (float num : nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        int i = (int) (num * k);\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets.get(i).add(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        Collections.sort(bucket);\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    int i = 0;\n    for (List<Float> bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\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\n    int k = nums.Length / 2;\n    List<List<float>> buckets = [];\n    for (int i = 0; i < k; i++) {\n        buckets.Add([]);\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    foreach (float num in nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        int i = (int)(num * k);\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].Add(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    foreach (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\n        bucket.Sort();\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    int j = 0;\n    foreach (List<float> bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\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\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i < k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for _, num := range nums {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        i := int(num * float64(k))\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for 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\n        sort.Float64s(buckets[i])\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\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\n    let k = nums.count / 2\n    var buckets = (0 ..< k).map { _ in [Double]() }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for num in nums {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        let i = Int(num * Double(k))\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].append(num)\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for 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\n        buckets[i].sort()\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\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\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i < k; i++) {\n        buckets.push([]);\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (const num of nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        const i = Math.floor(num * k);\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].push(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        bucket.sort((a, b) => a - b);\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[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\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i < k; i++) {\n        buckets.push([]);\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (const num of nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        const i = Math.floor(num * k);\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].push(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        bucket.sort((a, b) => a - b);\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\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\n  int k = nums.length ~/ 2;\n  List<List<double>> buckets = List.generate(k, (index) => []);\n\n  // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n  for (double _num in nums) {\n    // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 _num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n    int i = (_num * k).toInt();\n    // \u5c06 _num \u6dfb\u52a0\u8fdb\u6876 bucket_idx\n    buckets[i].add(_num);\n  }\n  // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n  for (List<double> bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n  int i = 0;\n  for (List<double> bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n
    bucket_sort.rs
    /* \u6876\u6392\u5e8f */\nfn bucket_sort(nums: &mut [f64]) {\n    // \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for &mut num in &mut *nums {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        let i = (num * k as f64) as usize;\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].push(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for bucket in &mut buckets {\n        // \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    let mut i = 0;\n    for bucket in &mut buckets {\n        for &mut num in bucket {\n            nums[i] = num;\n            i += 1;\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\n    int k = size / 2;\n    float **buckets = calloc(k, sizeof(float *));\n    for (int i = 0; i < k; i++) {\n        // \u6bcf\u4e2a\u6876\u6700\u591a\u53ef\u4ee5\u5206\u914d size \u4e2a\u5143\u7d20\n        buckets[i] = calloc(size, sizeof(float));\n    }\n\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (int i = 0; i < size; i++) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        int bucket_idx = nums[i] * k;\n        int 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\n        while (buckets[bucket_idx][j] > 0 && buckets[bucket_idx][j] < nums[i]) {\n            j++;\n        }\n        float temp = nums[i];\n        while (j < size && buckets[bucket_idx][j] > 0) {\n            swap(&temp, &buckets[bucket_idx][j]);\n            j++;\n        }\n        buckets[bucket_idx][j] = temp;\n    }\n\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (int i = 0; i < k; i++) {\n        qsort(buckets[i], size, sizeof(float), compare_float);\n    }\n\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    for (int i = 0, j = 0; j < k; j++) {\n        for (int l = 0; l < size; l++) {\n            if (buckets[j][l] > 0) {\n                nums[i++] = buckets[j][l];\n            }\n        }\n    }\n\n    // \u91ca\u653e\u4e0a\u8ff0\u5206\u914d\u7684\u5185\u5b58\n    for (int i = 0; i < k; i++) {\n        free(buckets[i]);\n    }\n    free(buckets);\n}\n
    bucket_sort.kt
    /* \u6876\u6392\u5e8f */\nfun bucketSort(nums: FloatArray) {\n    // \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\n    val k = nums.size / 2\n    val buckets = ArrayList<ArrayList<Float>>()\n    for (i in 0..<k) {\n        buckets.add(ArrayList())\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (num in nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        val i = (num * k).toInt()\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].add(num)\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        bucket.sort()\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n
    bucket_sort.rb
    [class]{}-[func]{bucket_sort}\n
    bucket_sort.zig
    [class]{}-[func]{bucketSort}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/bucket_sort/#1182","title":"11.8.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"

    \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

    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\u6240\u6709\u6876\u548c\u5143\u7d20\uff0c\u82b1\u8d39 \\(O(n + k)\\) \u65f6\u95f4\u3002
    • \u81ea\u9002\u5e94\u6392\u5e8f\uff1a\u5728\u6700\u5dee\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\u4e3a \\(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 \u4e2a\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\u6761\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

    \u5982\u56fe 11-14 \u6240\u793a\uff0c\u8fd9\u79cd\u65b9\u6cd5\u672c\u8d28\u4e0a\u662f\u521b\u5efa\u4e00\u68f5\u9012\u5f52\u6811\uff0c\u76ee\u6807\u662f\u8ba9\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

    \u56fe 11-14 \u00a0 \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\u56fe 11-15 \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

    \u56fe 11-15 \u00a0 \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\uff0c\u8ba1\u6570\u6392\u5e8f\u7684\u6574\u4f53\u6d41\u7a0b\u5982\u56fe 11-16 \u6240\u793a\u3002

    1. \u904d\u5386\u6570\u7ec4\uff0c\u627e\u51fa\u5176\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 \u3002
    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\u6392\u5e8f\u597d\u4e86\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u904d\u5386 counter \uff0c\u6839\u636e\u5404\u6570\u5b57\u51fa\u73b0\u6b21\u6570\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u586b\u5165 nums \u5373\u53ef\u3002

    \u56fe 11-16 \u00a0 \u8ba1\u6570\u6392\u5e8f\u6d41\u7a0b

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig counting_sort.py
    def counting_sort_naive(nums: list[int]):\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\n    m = 0\n    for num in nums:\n        m = 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\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\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\n    int m = 0;\n    for (int num : nums) {\n        m = 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\n    vector<int> counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    int i = 0;\n    for (int num = 0; num < m + 1; num++) {\n        for (int j = 0; j < counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n
    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\n    int m = 0;\n    for (int num : nums) {\n        m = 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\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    int i = 0;\n    for (int num = 0; num < m + 1; num++) {\n        for (int j = 0; j < counter[num]; j++, i++) {\n            nums[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\n    int m = 0;\n    foreach (int num in nums) {\n        m = 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\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    int i = 0;\n    for (int num = 0; num < m + 1; num++) {\n        for (int j = 0; j < counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\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\n    m := 0\n    for _, num := range nums {\n        if num > m {\n            m = 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\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    for i, num := 0, 0; num < m+1; num++ {\n        for j := 0; j < counter[num]; j++ {\n            nums[i] = num\n            i++\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\n    let 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\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    var i = 0\n    for num in 0 ..< m + 1 {\n        for _ in 0 ..< counter[num] {\n            nums[i] = num\n            i += 1\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\n    let m = 0;\n    for (const num of nums) {\n        m = 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\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    let i = 0;\n    for (let num = 0; num < m + 1; num++) {\n        for (let j = 0; j < counter[num]; j++, i++) {\n            nums[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\n    let m = 0;\n    for (const num of nums) {\n        m = 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\n    const counter: number[] = new Array<number>(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    let i = 0;\n    for (let num = 0; num < m + 1; num++) {\n        for (let j = 0; j < counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\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\n  int m = 0;\n  for (int _num in nums) {\n    m = 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\n  List<int> counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n  int i = 0;\n  for (int _num = 0; _num < m + 1; _num++) {\n    for (int j = 0; j < counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n
    counting_sort.rs
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfn counting_sort_naive(nums: &mut [i32]) {\n    // 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\n    let m = *nums.into_iter().max().unwrap();\n    // 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    // counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\n    let mut counter = vec![0; m as usize + 1];\n    for &num in &*nums {\n        counter[num as usize] += 1;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\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\n    int m = 0;\n    for (int i = 0; i < size; i++) {\n        if (nums[i] > m) {\n            m = 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\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i < size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    int i = 0;\n    for (int num = 0; num < m + 1; num++) {\n        for (int j = 0; j < counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. \u91ca\u653e\u5185\u5b58\n    free(counter);\n}\n
    counting_sort.kt
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfun countingSortNaive(nums: IntArray) {\n    // 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\n    var m = 0\n    for (num in nums) {\n        m = max(m.toDouble(), num.toDouble()).toInt()\n    }\n    // 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    // counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    var i = 0\n    for (num in 0..<m + 1) {\n        var j = 0\n        while (j < counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n
    counting_sort.rb
    [class]{}-[func]{counting_sort_naive}\n
    counting_sort.zig
    [class]{}-[func]{countingSortNaive}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\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\u8bfb\u8005\u53ef\u80fd\u53d1\u73b0\u4e86\uff0c\u5982\u679c\u8f93\u5165\u6570\u636e\u662f\u5bf9\u8c61\uff0c\u4e0a\u8ff0\u6b65\u9aa4 3. \u5c31\u5931\u6548\u4e86\u3002\u5047\u8bbe\u8f93\u5165\u6570\u636e\u662f\u5546\u54c1\u5bf9\u8c61\uff0c\u6211\u4eec\u60f3\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\u201c\u524d\u7f00\u548c\u201d\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\uff1a

    \\[ \\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\u4ee5\u4e0b\u4e24\u6b65\u3002

    1. \u5c06 num \u586b\u5165\u6570\u7ec4 res \u7684\u7d22\u5f15 prefix[num] - 1 \u5904\u3002
    2. \u4ee4\u524d\u7f00\u548c prefix[num] \u51cf\u5c0f \\(1\\) \uff0c\u4ece\u800c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\u3002

    \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\u56fe 11-17 \u5c55\u793a\u4e86\u5b8c\u6574\u7684\u8ba1\u6570\u6392\u5e8f\u6d41\u7a0b\u3002

    <1><2><3><4><5><6><7><8>

    \u56fe 11-17 \u00a0 \u8ba1\u6570\u6392\u5e8f\u6b65\u9aa4

    \u8ba1\u6570\u6392\u5e8f\u7684\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig counting_sort.py
    def counting_sort(nums: list[int]):\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\n    m = 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\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[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\n    for i in range(m):\n        counter[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\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for i in range(n):\n        nums[i] = res[i]\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\n    int m = 0;\n    for (int num : nums) {\n        m = 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\n    vector<int> counter(m + 1, 0);\n    for (int num : nums) {\n        counter[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\n    for (int i = 0; i < m; i++) {\n        counter[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\n    int n = nums.size();\n    vector<int> res(n);\n    for (int i = n - 1; i >= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    nums = res;\n}\n
    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\n    int m = 0;\n    for (int num : nums) {\n        m = 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\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[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\n    for (int i = 0; i < m; i++) {\n        counter[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\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i >= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (int i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\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\n    int m = 0;\n    foreach (int num in nums) {\n        m = 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\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[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\n    for (int i = 0; i < m; i++) {\n        counter[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\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i >= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (int i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\n}\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\n    m := 0\n    for _, num := range nums {\n        if num > m {\n            m = 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\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[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\n    for i := 0; i < m; i++ {\n        counter[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\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i >= 0; i-- {\n        num := nums[i]\n        // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        res[counter[num]-1] = num\n        // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n        counter[num]--\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\n    copy(nums, res)\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\n    let 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\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[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\n    for i in 0 ..< m {\n        counter[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\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\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\n    let m = 0;\n    for (const num of nums) {\n        m = 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\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[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\n    for (let i = 0; i < m; i++) {\n        counter[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\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i >= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (let i = 0; i < n; i++) {\n        nums[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\n    let m = 0;\n    for (const num of nums) {\n        m = 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\n    const counter: number[] = new Array<number>(m + 1).fill(0);\n    for (const num of nums) {\n        counter[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\n    for (let i = 0; i < m; i++) {\n        counter[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\n    const n = nums.length;\n    const res: number[] = new Array<number>(n);\n    for (let i = n - 1; i >= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (let i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\n}\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\n  int m = 0;\n  for (int _num in nums) {\n    m = 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\n  List<int> counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_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\n  for (int i = 0; i < m; i++) {\n    counter[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\n  int n = nums.length;\n  List<int> res = List.filled(n, 0);\n  for (int i = n - 1; i >= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // \u5c06 _num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n    counter[_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\n  nums.setAll(0, res);\n}\n
    counting_sort.rs
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfn counting_sort(nums: &mut [i32]) {\n    // 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\n    let m = *nums.into_iter().max().unwrap();\n    // 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    // counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\n    let mut counter = vec![0; m as usize + 1];\n    for &num in &*nums {\n        counter[num as usize] += 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\n    for i in 0..m as usize {\n        counter[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\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[num as usize] -= 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\n    for i in 0..n {\n        nums[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\n    int m = 0;\n    for (int i = 0; i < size; i++) {\n        if (nums[i] > m) {\n            m = 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\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i < size; i++) {\n        counter[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\n    for (int i = 0; i < m; i++) {\n        counter[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\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i >= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    memcpy(nums, res, size * sizeof(int));\n    // 5. \u91ca\u653e\u5185\u5b58\n    free(counter);\n}\n
    counting_sort.kt
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfun countingSort(nums: IntArray) {\n    // 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\n    var m = 0\n    for (num in nums) {\n        m = max(m.toDouble(), num.toDouble()).toInt()\n    }\n    // 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    // counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[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\n    for (i in 0..<m) {\n        counter[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\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (i in 0..<n) {\n        nums[i] = res[i]\n    }\n}\n
    counting_sort.rb
    [class]{}-[func]{counting_sort}\n
    counting_sort.zig
    [class]{}-[func]{countingSort}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/counting_sort/#1193","title":"11.9.3 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\u4e3a \\(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\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\u5c06\u5176\u7528\u4e8e\u5176\u4ed6\u7c7b\u578b\u7684\u6570\u636e\uff0c\u9700\u8981\u786e\u4fdd\u8fd9\u4e9b\u6570\u636e\u53ef\u4ee5\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\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\u201c\u5806\u201c\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\u3002

    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\u56fe 11-12 \u6240\u793a\u3002

    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. \u6b65\u548c\u7b2c 3. \u6b65\u3002\u5faa\u73af \\(n - 1\\) \u8f6e\u540e\uff0c\u5373\u53ef\u5b8c\u6210\u6570\u7ec4\u6392\u5e8f\u3002

    Tip

    \u5b9e\u9645\u4e0a\uff0c\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\u4e2d\u4e5f\u5305\u542b\u7b2c 2. \u6b65\u548c\u7b2c 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>

    \u56fe 11-12 \u00a0 \u5806\u6392\u5e8f\u6b65\u9aa4

    \u5728\u4ee3\u7801\u5b9e\u73b0\u4e2d\uff0c\u6211\u4eec\u4f7f\u7528\u4e86\u4e0e\u201c\u5806\u201d\u7ae0\u8282\u76f8\u540c\u7684\u4ece\u9876\u81f3\u5e95\u5806\u5316 sift_down() \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    while True:\n        # \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l < n and nums[l] > nums[ma]:\n            ma = l\n        if r < n and nums[r] > nums[ma]:\n            ma = r\n        # \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i:\n            break\n        # \u4ea4\u6362\u4e24\u8282\u70b9\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n\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\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for i in range(len(nums) - 1, 0, -1):\n        # \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        sift_down(nums, i, 0)\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) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l < n && nums[l] > nums[ma])\n            ma = l;\n        if (r < n && nums[r] > nums[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(nums[i], nums[ma]);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (int i = nums.size() / 2 - 1; i >= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (int i = nums.size() - 1; i > 0; --i) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        swap(nums[0], nums[i]);\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(nums, i, 0);\n    }\n}\n
    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) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l < n && nums[l] > nums[ma])\n            ma = l;\n        if (r < n && nums[r] > nums[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (int i = nums.length / 2 - 1; i >= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (int i = nums.length - 1; i > 0; i--) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(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) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l < n && nums[l] > nums[ma])\n            ma = l;\n        if (r < n && nums[r] > nums[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (int i = nums.Length / 2 - 1; i >= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (int i = nums.Length - 1; i > 0; i--) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        SiftDown(nums, i, 0);\n    }\n}\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) {\n    for true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l < n && (*nums)[l] > (*nums)[ma] {\n            ma = l\n        }\n        if r < n && (*nums)[r] > (*nums)[ma] {\n            ma = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\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\n    for i := len(*nums)/2 - 1; i >= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for i := len(*nums) - 1; i > 0; i-- {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        siftDown(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) {\n    var i = i\n    while true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l < n, nums[l] > nums[ma] {\n            ma = l\n        }\n        if r < n, nums[r] > nums[ma] {\n            ma = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        nums.swapAt(i, ma)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\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\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &nums, n: nums.count, i: i)\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for i in nums.indices.dropFirst().reversed() {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        nums.swapAt(0, i)\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(nums: &nums, n: i, 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) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l < n && nums[l] > nums[ma]) {\n            ma = l;\n        }\n        if (r < n && nums[r] > nums[ma]) {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (let i = nums.length - 1; i > 0; i--) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        siftDown(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 {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l < n && nums[l] > nums[ma]) {\n            ma = l;\n        }\n        if (r < n && nums[r] > nums[ma]) {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (let i = nums.length - 1; i > 0; i--) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        siftDown(nums, i, 0);\n    }\n}\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) {\n  while (true) {\n    // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l < n && nums[l] > nums[ma]) ma = l;\n    if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n    if (ma == i) break;\n    // \u4ea4\u6362\u4e24\u8282\u70b9\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n    i = ma;\n  }\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\n  for (int i = nums.length ~/ 2 - 1; i >= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n  for (int i = nums.length - 1; i > 0; i--) {\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n    siftDown(nums, i, 0);\n  }\n}\n
    heap_sort.rs
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfn sift_down(nums: &mut [i32], n: usize, mut i: usize) {\n    loop {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l < n && nums[l] > nums[ma] {\n            ma = l;\n        }\n        if r < n && nums[r] > nums[ma] {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        let temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n\n/* \u5806\u6392\u5e8f */\nfn heap_sort(nums: &mut [i32]) {\n    // \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in (0..=nums.len() / 2 - 1).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for i in (1..=nums.len() - 1).rev() {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        let tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        sift_down(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) {\n    while (1) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l < n && nums[l] > nums[ma])\n            ma = l;\n        if (r < n && nums[r] > nums[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (int i = n / 2 - 1; i >= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (int i = n - 1; i > 0; --i) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(nums, i, 0);\n    }\n}\n
    heap_sort.kt
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l < n && nums[l] > nums[ma]) ma = l\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) break\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        nums[i] = nums[ma].also { nums[ma] = nums[i] }\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\n}\n\n/* \u5806\u6392\u5e8f */\nfun heapSort(nums: IntArray) {\n    // \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (i in nums.size - 1 downTo 1) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        nums[0] = nums[i].also { nums[i] = nums[0] }\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(nums, i, 0)\n    }\n}\n
    heap_sort.rb
    [class]{}-[func]{sift_down}\n\n[class]{}-[func]{heap_sort}\n
    heap_sort.zig
    [class]{}-[func]{siftDown}\n\n[class]{}-[func]{heapSort}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/heap_sort/#1172","title":"11.7.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\u4e3a \\(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

    \u56fe 11-6 \u5c55\u793a\u4e86\u6570\u7ec4\u63d2\u5165\u5143\u7d20\u7684\u64cd\u4f5c\u6d41\u7a0b\u3002\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\u5c06 base \u8d4b\u503c\u7ed9\u76ee\u6807\u7d22\u5f15\u3002

    \u56fe 11-6 \u00a0 \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\u56fe 11-7 \u6240\u793a\u3002

    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

    \u56fe 11-7 \u00a0 \u63d2\u5165\u6392\u5e8f\u6d41\u7a0b

    \u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig insertion_sort.py
    def insertion_sort(nums: list[int]):\n    \"\"\"\u63d2\u5165\u6392\u5e8f\"\"\"\n    # \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = 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\n        while j >= 0 and nums[j] > base:\n            nums[j + 1] = nums[j]  # \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j -= 1\n        nums[j + 1] = base  # \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n
    insertion_sort.cpp
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(vector<int> &nums) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for (int i = 1; i < nums.size(); i++) {\n        int base = nums[i], j = 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\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    insertion_sort.java
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(int[] nums) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for (int i = 1; i < nums.length; i++) {\n        int base = nums[i], j = 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\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[j + 1] = base;        // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    insertion_sort.cs
    /* \u63d2\u5165\u6392\u5e8f */\nvoid InsertionSort(int[] nums) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for (int i = 1; i < nums.Length; i++) {\n        int bas = nums[i], j = 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\n        while (j >= 0 && nums[j] > bas) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[j + 1] = bas;         // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    insertion_sort.go
    /* \u63d2\u5165\u6392\u5e8f */\nfunc insertionSort(nums []int) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for i := 1; i < len(nums); i++ {\n        base := nums[i]\n        j := 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\n        for j >= 0 && nums[j] > base {\n            nums[j+1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--\n        }\n        nums[j+1] = base // \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\u533a\u95f4\u4e3a [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = 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\n        while j >= 0, nums[j] > base {\n            nums[j + 1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j -= 1\n        }\n        nums[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\u533a\u95f4\u4e3a [0, i-1]\n    for (let i = 1; i < nums.length; i++) {\n        let base = nums[i],\n            j = 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\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[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\u533a\u95f4\u4e3a [0, i-1]\n    for (let i = 1; i < nums.length; i++) {\n        const base = nums[i];\n        let j = 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\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[j + 1] = 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\u533a\u95f4\u4e3a [0, i-1]\n  for (int i = 1; i < nums.length; i++) {\n    int base = nums[i], j = 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\n    while (j >= 0 && nums[j] > base) {\n      nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n      j--;\n    }\n    nums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n  }\n}\n
    insertion_sort.rs
    /* \u63d2\u5165\u6392\u5e8f */\nfn insertion_sort(nums: &mut [i32]) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u533a\u95f4 [0, i-1] \u4e2d\u7684\u6b63\u786e\u4f4d\u7f6e\n        while j >= 0 && nums[j as usize] > base {\n            nums[(j + 1) as usize] = nums[j as usize]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = 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\u533a\u95f4\u4e3a [0, i-1]\n    for (int i = 1; i < size; i++) {\n        int base = nums[i], j = 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\n        while (j >= 0 && nums[j] > base) {\n            // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n        nums[j + 1] = base;\n    }\n}\n
    insertion_sort.kt
    /* \u63d2\u5165\u6392\u5e8f */\nfun insertionSort(nums: IntArray) {\n    //\u5916\u5faa\u73af: \u5df2\u6392\u5e8f\u5143\u7d20\u4e3a 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // \u5185\u5faa\u73af: \u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--\n        }\n        nums[j + 1] = base        // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    insertion_sort.rb
    [class]{}-[func]{insertion_sort}\n
    insertion_sort.zig
    // \u63d2\u5165\u6392\u5e8f\nfn insertionSort(nums: []i32) void {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    var i: usize = 1;\n    while (i < nums.len) : (i += 1) {\n        var base = nums[i];\n        var j: usize = i;\n        // \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u533a\u95f4 [0, i-1] \u4e2d\u7684\u6b63\u786e\u4f4d\u7f6e\n        while (j >= 1 and nums[j - 1] > base) : (j -= 1) {\n            nums[j] = nums[j - 1];  // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n        }\n        nums[j] = base;             // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/insertion_sort/#1142","title":"11.4.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\)\u3001\u81ea\u9002\u5e94\u6392\u5e8f\uff1a\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u6bcf\u6b21\u63d2\u5165\u64cd\u4f5c\u5206\u522b\u9700\u8981\u5faa\u73af \\(n - 1\\)\u3001\\(n-2\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \u6b21\uff0c\u6c42\u548c\u5f97\u5230 \\((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\u4e3a \\(O(1)\\)\u3001\u539f\u5730\u6392\u5e8f\uff1a\u6307\u9488 \\(i\\) \u548c \\(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\u7684\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\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\u7b56\u7565\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\u5730\u4f4d\uff0c\u6bcf\u8f6e\u4e2d\u7684\u5355\u5143\u64cd\u4f5c\u6570\u91cf\u8d77\u5230\u51b3\u5b9a\u6027\u4f5c\u7528\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\uff08\u4f8b\u5982 Java\uff09\u7684\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\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\u7b56\u7565\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\uff0c\u4e3b\u8981\u6709\u4ee5\u4e0b\u539f\u56e0\u3002

    • \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\u662f\u4e00\u79cd\u57fa\u4e8e\u5206\u6cbb\u7b56\u7565\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u5305\u542b\u56fe 11-10 \u6240\u793a\u7684\u201c\u5212\u5206\u201d\u548c\u201c\u5408\u5e76\u201d\u9636\u6bb5\u3002

    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\u3002
    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\u3002

    \u56fe 11-10 \u00a0 \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":"

    \u5982\u56fe 11-11 \u6240\u793a\uff0c\u201c\u5212\u5206\u9636\u6bb5\u201d\u4ece\u9876\u81f3\u5e95\u9012\u5f52\u5730\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5207\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\u3002

    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\u3002
    2. \u9012\u5f52\u6267\u884c\u6b65\u9aa4 1. \uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u533a\u95f4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u3002

    \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>

    \u56fe 11-11 \u00a0 \u5f52\u5e76\u6392\u5e8f\u6b65\u9aa4

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u5f52\u5e76\u6392\u5e8f\u4e0e\u4e8c\u53c9\u6811\u540e\u5e8f\u904d\u5386\u7684\u9012\u5f52\u987a\u5e8f\u662f\u4e00\u81f4\u7684\u3002

    • \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

    \u5f52\u5e76\u6392\u5e8f\u7684\u5b9e\u73b0\u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\u3002\u8bf7\u6ce8\u610f\uff0cnums \u7684\u5f85\u5408\u5e76\u533a\u95f4\u4e3a [left, right] \uff0c\u800c tmp \u7684\u5bf9\u5e94\u533a\u95f4\u4e3a [0, right - left] \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig merge_sort.py
    def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\"\"\"\n    # \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    # \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    tmp = [0] * (right - left + 1)\n    # \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    i, j, k = left, mid + 1, 0\n    # \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid and j <= right:\n        if nums[i] <= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j <= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"\u5f52\u5e76\u6392\u5e8f\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if left >= right:\n        return  # \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    # \u5212\u5206\u9636\u6bb5\n    mid = (left + right) // 2  # \u8ba1\u7b97\u4e2d\u70b9\n    merge_sort(nums, left, mid)  # \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    merge_sort(nums, mid + 1, right)  # \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    # \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right)\n
    merge_sort.cpp
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid merge(vector<int> &nums, int left, int mid, int right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    vector<int> tmp(right - left + 1);\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    int i = left, j = mid + 1, k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(vector<int> &nums, int left, int right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right)\n        return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    int mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.java
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    int[] tmp = new int[right - left + 1];\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    int i = left, j = mid + 1, k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int[] nums, int left, int right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right)\n        return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    int mid = (left + right) / 2; // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.cs
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    int[] tmp = new int[right - left + 1];\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    int i = left, j = mid + 1, k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid MergeSort(int[] nums, int left, int right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return;       // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    int mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\n    MergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    MergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    Merge(nums, left, mid, right);\n}\n
    merge_sort.go
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfunc merge(nums []int, left, mid, right int) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    tmp := make([]int, right-left+1)\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    i, j, k := left, mid+1, 0\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    for i <= mid && j <= right {\n        if nums[i] <= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    for i <= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j <= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for k := 0; k < len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfunc mergeSort(nums []int, left, right int) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if left >= right {\n        return\n    }\n    // \u5212\u5206\u9636\u6bb5\n    mid := (left + right) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right)\n}\n
    merge_sort.swift
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    var i = left, j = mid + 1, k = 0\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid, j <= right {\n        if nums[i] <= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j <= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if left >= right { // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n        return\n    }\n    // \u5212\u5206\u9636\u6bb5\n    let mid = (left + right) / 2 // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums: &nums, left: left, right: mid) // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums: &nums, left: mid + 1, right: right) // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums: &nums, left: left, mid: mid, right: right)\n}\n
    merge_sort.js
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfunction merge(nums, left, mid, right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    const tmp = new Array(right - left + 1);\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfunction mergeSort(nums, left, right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    let mid = Math.floor((left + right) / 2); // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.ts
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    const tmp = new Array(right - left + 1);\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    let mid = Math.floor((left + right) / 2); // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.dart
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid merge(List<int> nums, int left, int mid, int right) {\n  // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n  // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n  List<int> tmp = List.filled(right - left + 1, 0);\n  // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n  int i = left, j = mid + 1, k = 0;\n  // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n  while (i <= mid && j <= right) {\n    if (nums[i] <= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n  while (i <= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j <= right) {\n    tmp[k++] = nums[j++];\n  }\n  // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n  for (k = 0; k < tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(List<int> nums, int left, int right) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n  // \u5212\u5206\u9636\u6bb5\n  int mid = (left + right) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\n  mergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n  mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n  // \u5408\u5e76\u9636\u6bb5\n  merge(nums, left, mid, right);\n}\n
    merge_sort.rs
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfn merge(nums: &mut [i32], left: usize, mid: usize, right: usize) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid && j <= right {\n        if nums[i] <= nums[j] {\n            tmp[k] = nums[j];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j <= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfn merge_sort(nums: &mut [i32], left: usize, right: usize) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if left >= right {\n        return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    }\n\n    // \u5212\u5206\u9636\u6bb5\n    let mid = (left + right) / 2; // \u8ba1\u7b97\u4e2d\u70b9\n    merge_sort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    merge_sort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.c
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid merge(int *nums, int left, int mid, int right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    int i = left, j = mid + 1, k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // \u91ca\u653e\u5185\u5b58\n    free(tmp);\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int *nums, int left, int right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right)\n        return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    int mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.kt
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    val tmp = IntArray(right - left + 1)\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j]) tmp[k++] = nums[i++]\n        else tmp[k++] = nums[j++]\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++]\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return  // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    val mid = (left + right) / 2 // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid) // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right) // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right)\n}\n
    merge_sort.rb
    [class]{}-[func]{merge}\n\n[class]{}-[func]{merge_sort}\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\n    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);\n    defer mem_arena.deinit();\n    const mem_allocator = mem_arena.allocator();\n    var tmp = try mem_allocator.alloc(i32, right + 1 - left);\n    std.mem.copy(i32, tmp, nums[left..right+1]);\n    // \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15  \n    var leftStart = left - left;\n    var leftEnd = mid - left;\n    // \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15       \n    var rightStart = mid + 1 - left;\n    var rightEnd = right - left;\n    // i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\n    var i = leftStart;\n    var j = rightStart;\n    // \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\n    var k = left;\n    while (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++\n        if (i > leftEnd) {\n            nums[k] = tmp[j];\n            j += 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]) {\n            nums[k] = tmp[i];\n            i += 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 {\n            nums[k] = tmp[j];\n            j += 1;\n        }\n    }\n}\n\n// \u5f52\u5e76\u6392\u5e8f\nfn mergeSort(nums: []i32, left: usize, right: usize) !void {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return;              // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    var mid = (left + right) / 2;           // \u8ba1\u7b97\u4e2d\u70b9\n    try mergeSort(nums, left, mid);         // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    try mergeSort(nums, mid + 1, right);    // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    try merge(nums, left, mid, right);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/merge_sort/#1162","title":"11.6.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\u4e3a \\(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":"

    \u5bf9\u4e8e\u94fe\u8868\uff0c\u5f52\u5e76\u6392\u5e8f\u76f8\u8f83\u4e8e\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\u5177\u6709\u663e\u8457\u4f18\u52bf\uff0c\u53ef\u4ee5\u5c06\u94fe\u8868\u6392\u5e8f\u4efb\u52a1\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(1)\\) \u3002

    • \u5212\u5206\u9636\u6bb5\uff1a\u53ef\u4ee5\u4f7f\u7528\u201c\u8fed\u4ee3\u201d\u66ff\u4ee3\u201c\u9012\u5f52\u201d\u6765\u5b9e\u73b0\u94fe\u8868\u5212\u5206\u5de5\u4f5c\uff0c\u4ece\u800c\u7701\u53bb\u9012\u5f52\u4f7f\u7528\u7684\u6808\u5e27\u7a7a\u95f4\u3002
    • \u5408\u5e76\u9636\u6bb5\uff1a\u5728\u94fe\u8868\u4e2d\uff0c\u8282\u70b9\u589e\u5220\u64cd\u4f5c\u4ec5\u9700\u6539\u53d8\u5f15\u7528\uff08\u6307\u9488\uff09\u5373\u53ef\u5b9e\u73b0\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\u987b\u521b\u5efa\u989d\u5916\u94fe\u8868\u3002

    \u5177\u4f53\u5b9e\u73b0\u7ec6\u8282\u6bd4\u8f83\u590d\u6742\uff0c\u6709\u5174\u8da3\u7684\u8bfb\u8005\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\u7b56\u7565\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\u201c\u54e8\u5175\u5212\u5206\u201d\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\u5982\u56fe 11-8 \u6240\u793a\u3002

    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\u3002
    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\u3002
    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\u3002
    <1><2><3><4><5><6><7><8><9>

    \u56fe 11-8 \u00a0 \u54e8\u5175\u5212\u5206\u6b65\u9aa4

    \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

    \u5feb\u901f\u6392\u5e8f\u7684\u5206\u6cbb\u7b56\u7565

    \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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig quick_sort.py
    def partition(self, nums: list[int], left: int, right: int) -> int:\n    \"\"\"\u54e8\u5175\u5212\u5206\"\"\"\n    # \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    i, j = left, right\n    while i < j:\n        while i < j and nums[j] >= nums[left]:\n            j -= 1  # \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while i < j and nums[i] <= nums[left]:\n            i += 1  # \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        # \u5143\u7d20\u4ea4\u6362\n        nums[i], nums[j] = nums[j], nums[i]\n    # \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n
    quick_sort.cpp
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(vector<int> &nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nint partition(vector<int> &nums, int left, int right) {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.java
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nint partition(int[] nums, int left, int right) {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cs
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nint Partition(int[] nums, int left, int right) {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.go
    /* \u54e8\u5175\u5212\u5206 */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    i, j := left, right\n    for i < j {\n        for i < j && nums[j] >= nums[left] {\n            j-- // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        for i < j && nums[i] <= nums[left] {\n            i++ // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        // \u5143\u7d20\u4ea4\u6362\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.swift
    /* \u54e8\u5175\u5212\u5206 */\nfunc partition(nums: inout [Int], left: Int, right: Int) -> Int {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    var i = left\n    var j = right\n    while i < j {\n        while i < j, nums[j] >= nums[left] {\n            j -= 1 // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while i < j, nums[i] <= nums[left] {\n            i += 1 // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        nums.swapAt(i, j) // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    nums.swapAt(i, left) // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return i // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.js
    /* \u5143\u7d20\u4ea4\u6362 */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\npartition(nums, left, right) {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let i = left,\n        j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        // \u5143\u7d20\u4ea4\u6362\n        this.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    this.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return 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 {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\npartition(nums: number[], left: number, right: number): number {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let i = left,\n        j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        // \u5143\u7d20\u4ea4\u6362\n        this.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    this.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return 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) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nint _partition(List<int> nums, int left, int right) {\n  // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n  int i = left, j = right;\n  while (i < j) {\n    while (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n    while (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\n  return i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.rs
    /* \u54e8\u5175\u5212\u5206 */\nfn partition(nums: &mut [i32], left: usize, right: usize) -> usize {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let (mut i, mut j) = (left, right);\n    while i < j {\n        while i < j && nums[j] >= nums[left] {\n            j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while i < j && nums[i] <= nums[left] {\n            i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        nums.swap(i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    nums.swap(i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    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) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n            j--;\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n            i++;\n        }\n        // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n        swap(nums, i, j);\n    }\n    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    swap(nums, i, left);\n    // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n    return i;\n}\n
    quick_sort.kt
    /* \u5143\u7d20\u4ea4\u6362 */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    nums[i] = nums[j].also { nums[j] = nums[i] }\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    var i = left\n    var j = right\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--           // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i              // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.rb
    [class]{QuickSort}-[func]{partition}\n
    quick_sort.zig
    // \u5143\u7d20\u4ea4\u6362\nfn swap(nums: []i32, i: usize, j: usize) void {\n    var tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n// \u54e8\u5175\u5212\u5206\nfn partition(nums: []i32, left: usize, right: usize) usize {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    var i = left;\n    var j = right;\n    while (i < j) {\n        while (i < j and nums[j] >= nums[left]) j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j and nums[i] <= nums[left]) i += 1; // \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\n    return i;               // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/quick_sort/#1151","title":"11.5.1 \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u5feb\u901f\u6392\u5e8f\u7684\u6574\u4f53\u6d41\u7a0b\u5982\u56fe 11-9 \u6240\u793a\u3002

    1. \u9996\u5148\uff0c\u5bf9\u539f\u6570\u7ec4\u6267\u884c\u4e00\u6b21\u201c\u54e8\u5175\u5212\u5206\u201d\uff0c\u5f97\u5230\u672a\u6392\u5e8f\u7684\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u3002
    2. \u7136\u540e\uff0c\u5bf9\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u5206\u522b\u9012\u5f52\u6267\u884c\u201c\u54e8\u5175\u5212\u5206\u201d\u3002
    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\u3002

    \u56fe 11-9 \u00a0 \u5feb\u901f\u6392\u5e8f\u6d41\u7a0b

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig quick_sort.py
    def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"\u5feb\u901f\u6392\u5e8f\"\"\"\n    # \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    if left >= right:\n        return\n    # \u54e8\u5175\u5212\u5206\n    pivot = self.partition(nums, left, right)\n    # \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\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\n    if (left >= right)\n        return;\n    // \u54e8\u5175\u5212\u5206\n    int pivot = partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n
    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\n    if (left >= right)\n        return;\n    // \u54e8\u5175\u5212\u5206\n    int pivot = partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1);\n    quickSort(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\n    if (left >= right)\n        return;\n    // \u54e8\u5175\u5212\u5206\n    int pivot = Partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\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\n    if left >= right {\n        return\n    }\n    // \u54e8\u5175\u5212\u5206\n    pivot := q.partition(nums, left, right)\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(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\n    if left >= right {\n        return\n    }\n    // \u54e8\u5175\u5212\u5206\n    let pivot = partition(nums: &nums, left: left, right: right)\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums: &nums, left: left, right: pivot - 1)\n    quickSort(nums: &nums, left: pivot + 1, right: 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\n    if (left >= right) return;\n    // \u54e8\u5175\u5212\u5206\n    const pivot = this.partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    this.quickSort(nums, left, pivot - 1);\n    this.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\n    if (left >= right) {\n        return;\n    }\n    // \u54e8\u5175\u5212\u5206\n    const pivot = this.partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(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\n  if (left >= right) return;\n  // \u54e8\u5175\u5212\u5206\n  int pivot = _partition(nums, left, right);\n  // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n
    quick_sort.rs
    /* \u5feb\u901f\u6392\u5e8f */\npub fn quick_sort(left: i32, right: i32, nums: &mut [i32]) {\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    if left >= right {\n        return;\n    }\n    // \u54e8\u5175\u5212\u5206\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n            j--;\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n            i++;\n        }\n        // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n        swap(nums, i, j);\n    }\n    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    swap(nums, i, left);\n    // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n    return i;\n}\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\n    if (left >= right) {\n        return;\n    }\n    // \u54e8\u5175\u5212\u5206\n    int pivot = partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n
    quick_sort.kt
    /* \u5feb\u901f\u6392\u5e8f */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    if (left >= right) return\n    // \u54e8\u5175\u5212\u5206\n    val pivot = partition(nums, left, right)\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n
    quick_sort.rb
    [class]{QuickSort}-[func]{quick_sort}\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\n    if (left >= right) return;\n    // \u54e8\u5175\u5212\u5206\n    var pivot = partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/quick_sort/#1152","title":"11.5.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\\) \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\u4e3a \\(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\u901f\u6392\u5e8f\u4e3a\u4ec0\u4e48\u5feb","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\u201c\u5f52\u5e76\u6392\u5e8f\u201d\u548c\u201c\u5806\u6392\u5e8f\u201d\u76f8\u540c\uff0c\u4f46\u901a\u5e38\u5feb\u901f\u6392\u5e8f\u7684\u6548\u7387\u66f4\u9ad8\uff0c\u4e3b\u8981\u6709\u4ee5\u4e0b\u539f\u56e0\u3002

    • \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\u201c\u5806\u6392\u5e8f\u201d\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\u5c0f\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\u201c\u63d2\u5165\u6392\u5e8f\u201d\u6bd4\u201c\u5192\u6ce1\u6392\u5e8f\u201d\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\u90fd\u6709\u4e00\u4e2a\u5b50\u6570\u7ec4\u7684\u957f\u5ea6\u4e3a \\(0\\) \uff0c\u5206\u6cbb\u7b56\u7565\u5931\u6548\uff0c\u5feb\u901f\u6392\u5e8f\u9000\u5316\u4e3a\u201c\u5192\u6ce1\u6392\u5e8f\u201d\u7684\u8fd1\u4f3c\u5f62\u5f0f\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

    \u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig quick_sort.py
    def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:\n    \"\"\"\u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l <= m <= r) or (r <= m <= l):\n        return mid  # m \u5728 l \u548c r \u4e4b\u95f4\n    if (m <= l <= r) or (r <= l <= m):\n        return left  # l \u5728 m \u548c r \u4e4b\u95f4\n    return right\n\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] \u4e3a\u57fa\u51c6\u6570\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    nums[left], nums[med] = nums[med], nums[left]\n    # \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    i, j = left, right\n    while i < j:\n        while i < j and nums[j] >= nums[left]:\n            j -= 1  # \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while i < j and nums[i] <= nums[left]:\n            i += 1  # \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        # \u5143\u7d20\u4ea4\u6362\n        nums[i], nums[j] = nums[j], nums[i]\n    # \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n
    quick_sort.cpp
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(vector<int> &nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return right;\n}\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\n    int 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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.java
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return right;\n}\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\n    int 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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cs
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return right;\n}\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\n    int 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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.go
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l <= m && m <= r) || (r <= m && m <= l) {\n        return mid // m \u5728 l \u548c r \u4e4b\u95f4\n    }\n    if (m <= l && l <= r) || (r <= l && l <= m) {\n        return left // l \u5728 m \u548c r \u4e4b\u95f4\n    }\n    return right\n}\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] \u4e3a\u57fa\u51c6\u6570\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    nums[left], nums[med] = nums[med], nums[left]\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    i, j := left, right\n    for i < j {\n        for i < j && nums[j] >= nums[left] {\n            j-- //\u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        for i < j && nums[i] <= nums[left] {\n            i++ //\u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        //\u5143\u7d20\u4ea4\u6362\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    //\u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    nums[i], nums[left] = nums[left], nums[i]\n    return i //\u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.swift
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -> Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l <= m && m <= r) || (r <= m && m <= l) {\n        return mid // m \u5728 l \u548c r \u4e4b\u95f4\n    }\n    if (m <= l && l <= r) || (r <= l && l <= m) {\n        return left // l \u5728 m \u548c r \u4e4b\u95f4\n    }\n    return 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\n    let 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\n    nums.swapAt(left, med)\n    return partition(nums: &nums, left: left, right: right)\n}\n
    quick_sort.js
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;\n    // l \u5728 m \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m)) return left;\n    return right;\n}\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\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    this.swap(nums, left, med);\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let i = left,\n        j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left]) i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        this.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    this.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.ts
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;\n    // l \u5728 m \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m)) return left;\n    return 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\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    this.swap(nums, left, med);\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let i = left,\n        j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        this.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    this.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.dart
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint _medianThree(List<int> nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l <= m && m <= r) || (r <= m && m <= l))\n    return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n  if ((m <= l && l <= r) || (r <= l && l <= m))\n    return left; // l \u5728 m \u548c r \u4e4b\u95f4\n  return right;\n}\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\n  int 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] \u4e3a\u57fa\u51c6\u6570\n  int i = left, j = right;\n  while (i < j) {\n    while (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n    while (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\n  return i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.rs
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfn median_three(nums: &mut [i32], left: usize, mid: usize, right: usize) -> usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l <= m && m <= r) || (r <= m && m <= l) {\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    }\n    if (m <= l && l <= r) || (r <= l && l <= m) {\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    }\n    right\n}\n\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nfn partition(nums: &mut [i32], left: usize, right: usize) -> usize {\n    // \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    nums.swap(left, med);\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let (mut i, mut j) = (left, right);\n    while i < j {\n        while i < j && nums[j] >= nums[left] {\n            j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while i < j && nums[i] <= nums[left] {\n            i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        nums.swap(i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    nums.swap(i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    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\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return right;\n}\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\n    int 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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.kt
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((l in m..r) || (l in r..m))\n        return left // l \u5728 m \u548c r \u4e4b\u95f4\n    return right\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    var i = left\n    var j = right\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--           // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i              // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.rb
    [class]{QuickSortMedian}-[func]{median_three}\n\n[class]{QuickSortMedian}-[func]{partition}\n
    quick_sort.zig
    // \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nfn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {\n    var l = nums[left];\n    var m = nums[mid];\n    var r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return 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\n    var 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] \u4e3a\u57fa\u51c6\u6570\n    var i = left;\n    var j = right;\n    while (i < j) {\n        while (i < j and nums[j] >= nums[left]) j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j and nums[i] <= nums[left]) i += 1; // \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\n    return i;               // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u6709\u5e8f\u7684\u8f93\u5165\u6570\u7ec4\u4e3a\u4f8b\uff0c\u8bbe\u9012\u5f52\u4e2d\u7684\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a \\(m\\) \uff0c\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u64cd\u4f5c\u90fd\u5c06\u4ea7\u751f\u957f\u5ea6\u4e3a \\(0\\) \u7684\u5de6\u5b50\u6570\u7ec4\u548c\u957f\u5ea6\u4e3a \\(m - 1\\) \u7684\u53f3\u5b50\u6570\u7ec4\uff0c\u8fd9\u610f\u5473\u7740\u6bcf\u4e00\u5c42\u9012\u5f52\u8c03\u7528\u51cf\u5c11\u7684\u95ee\u9898\u89c4\u6a21\u975e\u5e38\u5c0f\uff08\u53ea\u51cf\u5c11\u4e00\u4e2a\u5143\u7d20\uff09\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 \\(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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig quick_sort.py
    def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"\u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\"\"\"\n    # \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\n    while left < right:\n        # \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        pivot = self.partition(nums, left, right)\n        # \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if pivot - left < right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1  # \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1  # \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        int pivot = partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1;                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1;                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n        }\n    }\n}\n
    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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        int pivot = partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        int pivot = Partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1;  // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n        }\n    }\n}\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\n    for left < right {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        pivot := q.partition(nums, left, right)\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if pivot-left < right-pivot {\n            q.quickSort(nums, left, pivot-1) // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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) {\n    var left = left\n    var right = right\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\n    while left < right {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        let pivot = partition(nums: &nums, left: left, right: right)\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left) < (right - pivot) {\n            quickSortTailCall(nums: &nums, left: left, right: pivot - 1) // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &nums, left: pivot + 1, right: right) // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        let pivot = this.partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        let pivot = this.partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n  while (left < right) {\n    // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n    int pivot = _partition(nums, left, right);\n    // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n    if (pivot - left < right - pivot) {\n      quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n      left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n      right = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n    }\n  }\n}\n
    quick_sort.rs
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &mut [i32]) {\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\n    while left < right {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if pivot - left < right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        int pivot = partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            quickSortTailCall(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1;                         // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1;                         // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n        }\n    }\n}\n
    quick_sort.kt
    /* \u5feb\u901f\u6392\u5e8f */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    if (left >= right) return\n    // \u54e8\u5175\u5212\u5206\n    val pivot = partition(nums, left, right)\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n
    quick_sort.rb
    [class]{QuickSortTailCall}-[func]{quick_sort}\n
    quick_sort.zig
    // \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\nfn quickSort(nums: []i32, left_: usize, right_: usize) void {\n    var left = left_;\n    var right = right_;\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        var pivot = partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            quickSort(nums, left, pivot - 1);   // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1;                   // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right);  // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1;                  // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n        }\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/radix_sort/","title":"11.10 \u00a0 \u57fa\u6570\u6392\u5e8f","text":"

    \u4e0a\u4e00\u8282\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\u6d41\u7a0b\u5982\u56fe 11-18 \u6240\u793a\u3002

    1. \u521d\u59cb\u5316\u4f4d\u6570 \\(k = 1\\) \u3002
    2. \u5bf9\u5b66\u53f7\u7684\u7b2c \\(k\\) \u4f4d\u6267\u884c\u201c\u8ba1\u6570\u6392\u5e8f\u201d\u3002\u5b8c\u6210\u540e\uff0c\u6570\u636e\u4f1a\u6839\u636e\u7b2c \\(k\\) \u4f4d\u4ece\u5c0f\u5230\u5927\u6392\u5e8f\u3002
    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\u3002

    \u56fe 11-18 \u00a0 \u57fa\u6570\u6392\u5e8f\u7b97\u6cd5\u6d41\u7a0b

    \u4e0b\u9762\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 \\: d\\) \u8868\u793a\u5bf9 \\(d\\) \u53d6\u6a21\uff08\u53d6\u4f59\uff09\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\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\u6570\u7ec4\n    counter = [0] * 10\n    n = len(nums)\n    # \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for i in range(n):\n        d = digit(nums[i], exp)  # \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for i in range(1, 10):\n        counter[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\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]  # \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d] -= 1  # \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    # \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"\u57fa\u6570\u6392\u5e8f\"\"\"\n    # \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\n    m = max(nums)\n    # \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    exp = 1\n    while 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)\n        counting_sort_digit(nums, exp)\n        exp *= 10\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\n    return (num / exp) % 10;\n}\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\u6570\u7ec4\n    vector<int> counter(10, 0);\n    int n = nums.size();\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (int i = 0; i < n; i++) {\n        int d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (int i = 1; i < 10; i++) {\n        counter[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\n    vector<int> res(n, 0);\n    for (int i = n - 1; i >= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (int i = 0; i < n; i++)\n        nums[i] = res[i];\n}\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\n    int m = *max_element(nums.begin(), nums.end());\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(nums, exp);\n}\n
    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\n    return (num / exp) % 10;\n}\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\u6570\u7ec4\n    int[] counter = new int[10];\n    int n = nums.length;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (int i = 0; i < n; i++) {\n        int d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (int i = 1; i < 10; i++) {\n        counter[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\n    int[] res = new int[n];\n    for (int i = n - 1; i >= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (int i = 0; i < n; i++)\n        nums[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\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num > m)\n            m = num;\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(nums, 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\n    return (num / exp) % 10;\n}\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\u6570\u7ec4\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (int i = 0; i < n; i++) {\n        int d = Digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (int i = 1; i < 10; i++) {\n        counter[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\n    int[] res = new int[n];\n    for (int i = n - 1; i >= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (int i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\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\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num > m) m = num;\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        CountingSortDigit(nums, exp);\n    }\n}\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\n    return (num / exp) % 10\n}\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\u6570\u7ec4\n    counter := make([]int, 10)\n    n := len(nums)\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for i := 0; i < n; i++ {\n        d := digit(nums[i], exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for i := 1; i < 10; i++ {\n        counter[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\n    res := make([]int, n)\n    for i := n - 1; i >= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]    // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--        // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for i := 0; i < n; i++ {\n        nums[i] = res[i]\n    }\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\n    max := math.MinInt\n    for _, num := range nums {\n        if num > max {\n            max = num\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for 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)\n        countingSortDigit(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\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\u6570\u7ec4\n    var counter = Array(repeating: 0, count: 10)\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for i in 1 ..< 10 {\n        counter[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\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i] // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d] -= 1 // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\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\n    var m = Int.min\n    for num in nums {\n        if num > m {\n            m = num\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for 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)\n        countingSortDigit(nums: &nums, exp: 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\n    return Math.floor(num / exp) % 10;\n}\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\u6570\u7ec4\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (let i = 0; i < n; i++) {\n        const d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (let i = 1; i < 10; i++) {\n        counter[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\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i >= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (let i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\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\n    let m = Number.MIN_VALUE;\n    for (const num of nums) {\n        if (num > m) {\n            m = num;\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(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\n    return Math.floor(num / exp) % 10;\n}\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\u6570\u7ec4\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (let i = 0; i < n; i++) {\n        const d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (let i = 1; i < 10; i++) {\n        counter[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\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i >= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (let i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\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\n    let m = Number.MIN_VALUE;\n    for (const num of nums) {\n        if (num > m) {\n            m = num;\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(nums, exp);\n    }\n}\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\n  return (_num ~/ exp) % 10;\n}\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\u6570\u7ec4\n  List<int> counter = List<int>.filled(10, 0);\n  int n = nums.length;\n  // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n  for (int i = 0; i < n; i++) {\n    int d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n    counter[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\n  for (int i = 1; i < 10; i++) {\n    counter[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\n  List<int> res = List<int>.filled(n, 0);\n  for (int i = n - 1; i >= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n    res[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n    counter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n  }\n  // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n  for (int i = 0; i < n; i++) nums[i] = res[i];\n}\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\n  int m = -1 << 63;\n  for (int _num in nums) if (_num > m) m = _num;\n  // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n  for (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)\n    countingSortDigit(nums, exp);\n}\n
    radix_sort.rs
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfn digit(num: i32, exp: i32) -> usize {\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    return ((num / exp) % 10) as usize;\n}\n\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfn counting_sort_digit(nums: &mut [i32], exp: i32) {\n    // \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\u6570\u7ec4\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for i in 0..n {\n        let d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for i in 1..10 {\n        counter[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\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d] -= 1; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for i in 0..n {\n        nums[i] = res[i];\n    }\n}\n\n/* \u57fa\u6570\u6392\u5e8f */\nfn radix_sort(nums: &mut [i32]) {\n    // \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\n    let m = *nums.into_iter().max().unwrap();\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    let mut exp = 1;\n    while exp <= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\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\n    return (num / exp) % 10;\n}\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\u6570\u7ec4\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (int i = 0; i < size; i++) {\n        // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        int d = digit(nums[i], exp);\n        // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n        counter[d]++;\n    }\n    // \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\n    for (int i = 1; i < 10; i++) {\n        counter[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\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i >= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (int i = 0; i < size; i++) {\n        nums[i] = res[i];\n    }\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\n    int max = INT32_MIN;\n    for (size_t i = 0; i < size - 1; i++) {\n        if (nums[i] > max) {\n            max = nums[i];\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(nums, size, exp);\n}\n
    radix_sort.kt
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfun 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    return (num / exp) % 10\n}\n\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\u6570\u7ec4\n    val counter = IntArray(10)\n    val n = nums.size\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (i in 0..<n) {\n        val d = digit(nums[i], exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (i in 1..9) {\n        counter[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\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i] // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]-- // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (i in 0..<n) nums[i] = res[i]\n}\n\n/* \u57fa\u6570\u6392\u5e8f */\nfun radixSort(nums: IntArray) {\n    // \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num > m) m = num\n    var exp = 1\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    while (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)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n
    radix_sort.rb
    [class]{}-[func]{digit}\n\n[class]{}-[func]{counting_sort_digit}\n\n[class]{}-[func]{radix_sort}\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\n    return @mod(@divFloor(num, exp), 10);\n}\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\u6570\u7ec4\n    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);\n    // defer mem_arena.deinit();\n    const mem_allocator = mem_arena.allocator();\n    var counter = try mem_allocator.alloc(usize, 10);\n    @memset(counter, 0);\n    var n = nums.len;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (nums) |num| {\n        var d: u32 = @bitCast(digit(num, exp)); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    var i: usize = 1;\n    while (i < 10) : (i += 1) {\n        counter[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\n    var res = try mem_allocator.alloc(i32, n);\n    i = n - 1;\n    while (i >= 0) : (i -= 1) {\n        var d: u32 = @bitCast(digit(nums[i], exp));\n        var j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d] -= 1;        // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n        if (i == 0) break;\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    i = 0;\n    while (i < n) : (i += 1) {\n        nums[i] = res[i];\n    }\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\n    var m: i32 = std.math.minInt(i32);\n    for (nums) |num| {\n        if (num > m) m = num;\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    var exp: i32 = 1;\n    while (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)\n        try countingSortDigit(nums, exp);    \n    }\n} \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\u56e0\u6b64\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\u4e3a \\(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\u4e3a \\(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\u5f53\u8ba1\u6570\u6392\u5e8f\u7a33\u5b9a\u65f6\uff0c\u57fa\u6570\u6392\u5e8f\u4e5f\u7a33\u5b9a\uff1b\u5f53\u8ba1\u6570\u6392\u5e8f\u4e0d\u7a33\u5b9a\u65f6\uff0c\u57fa\u6570\u6392\u5e8f\u65e0\u6cd5\u4fdd\u8bc1\u5f97\u5230\u6b63\u786e\u7684\u6392\u5e8f\u7ed3\u679c\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\u7b80\u5355\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\u56fe 11-2 \u6240\u793a\u3002

    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\u7684\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\u7684\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\u987b\u6392\u5e8f\uff0c\u56e0\u6b64\u6570\u7ec4\u6392\u5e8f\u5b8c\u6210\u3002
    <1><2><3><4><5><6><7><8><9><10><11>

    \u56fe 11-2 \u00a0 \u9009\u62e9\u6392\u5e8f\u6b65\u9aa4

    \u5728\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u7528 \\(k\\) \u6765\u8bb0\u5f55\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig selection_sort.py
    def selection_sort(nums: list[int]):\n    \"\"\"\u9009\u62e9\u6392\u5e8f\"\"\"\n    n = len(nums)\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for i in range(n - 1):\n        # \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] < nums[k]:\n                k = 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\n        nums[i], nums[k] = nums[k], nums[i]\n
    selection_sort.cpp
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(vector<int> &nums) {\n    int n = nums.size();\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        int k = i;\n        for (int j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k])\n                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\n        swap(nums[i], nums[k]);\n    }\n}\n
    selection_sort.java
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        int k = i;\n        for (int j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k])\n                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\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n
    selection_sort.cs
    /* \u9009\u62e9\u6392\u5e8f */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        int k = i;\n        for (int j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k])\n                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\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n
    selection_sort.go
    /* \u9009\u62e9\u6392\u5e8f */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for i := 0; i < n-1; i++ {\n        // \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        k := i\n        for j := i + 1; j < n; j++ {\n            if nums[j] < nums[k] {\n                // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n                k = j\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}\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]\n    for i in nums.indices.dropLast() {\n        // \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] < nums[k] {\n                k = 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.swapAt(i, k)\n    }\n}\n
    selection_sort.js
    /* \u9009\u62e9\u6392\u5e8f */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        let k = i;\n        for (let j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k]) {\n                k = 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 {\n    let n = nums.length;\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        let k = i;\n        for (let j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k]) {\n                k = 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.dart
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(List<int> nums) {\n  int n = nums.length;\n  // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n  for (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\n    int k = i;\n    for (int j = i + 1; j < n; j++) {\n      if (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\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n
    selection_sort.rs
    /* \u9009\u62e9\u6392\u5e8f */\nfn selection_sort(nums: &mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for i in 0..n - 1 {\n        // \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] < nums[k] {\n                k = 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.swap(i, k);\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]\n    for (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\n        int k = i;\n        for (int j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k])\n                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\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n
    selection_sort.kt
    /* \u9009\u62e9\u6392\u5e8f */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (i in 0..<n - 1) {\n        var k = i\n        // \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        for (j in i + 1..<n) {\n            if (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\n        nums[i] = nums[k].also { nums[k] = nums[i] }\n    }\n}\n
    selection_sort.rb
    [class]{}-[func]{selection_sort}\n
    selection_sort.zig
    [class]{}-[func]{selectionSort}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\\)\u3001\\(n - 1\\)\u3001\\(\\dots\\)\u3001\\(3\\)\u3001\\(2\\) \u8f6e\u5185\u5faa\u73af\uff0c\u6c42\u548c\u4e3a \\(\\frac{(n - 1)(n + 2)}{2}\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\)\u3001\u539f\u5730\u6392\u5e8f\uff1a\u6307\u9488 \\(i\\) \u548c \\(j\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u975e\u7a33\u5b9a\u6392\u5e8f\uff1a\u5982\u56fe 11-3 \u6240\u793a\uff0c\u5143\u7d20 nums[i] \u6709\u53ef\u80fd\u88ab\u4ea4\u6362\u81f3\u4e0e\u5176\u76f8\u7b49\u7684\u5143\u7d20\u7684\u53f3\u8fb9\uff0c\u5bfc\u81f4\u4e24\u8005\u7684\u76f8\u5bf9\u987a\u5e8f\u53d1\u751f\u6539\u53d8\u3002

    \u56fe 11-3 \u00a0 \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\u9ad8\u6548\u5730\u67e5\u627e\u3001\u5206\u6790\u548c\u5904\u7406\u3002

    \u5982\u56fe 11-1 \u6240\u793a\uff0c\u6392\u5e8f\u7b97\u6cd5\u4e2d\u7684\u6570\u636e\u7c7b\u578b\u53ef\u4ee5\u662f\u6574\u6570\u3001\u6d6e\u70b9\u6570\u3001\u5b57\u7b26\u6216\u5b57\u7b26\u4e32\u7b49\u3002\u6392\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

    \u56fe 11-1 \u00a0 \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\u65f6\u95f4\u590d\u6742\u5ea6\u4e2d\u7684\u5e38\u6570\u9879\u53d8\u5c0f\uff09\u3002\u5bf9\u4e8e\u5927\u6570\u636e\u91cf\u7684\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\u987b\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\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 \u5217\u548c\u7b2c 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\uff1a

    # \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\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\u65f6\u95f4\u590d\u6742\u5ea6\u3001\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\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\u6bd4\u8f83\u8fd0\u7b97\u7b26\uff08\\(<\\)\u3001\\(=\\)\u3001\\(>\\)\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":""},{"location":"chapter_sorting/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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\u56e0\u6b64\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
    • \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
    • \u56fe 11-19 \u5bf9\u6bd4\u4e86\u4e3b\u6d41\u6392\u5e8f\u7b97\u6cd5\u7684\u6548\u7387\u3001\u7a33\u5b9a\u6027\u3001\u5c31\u5730\u6027\u548c\u81ea\u9002\u5e94\u6027\u7b49\u3002

    \u56fe 11-19 \u00a0 \u6392\u5e8f\u7b97\u6cd5\u5bf9\u6bd4

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

    Q\uff1a\u6392\u5e8f\u7b97\u6cd5\u7a33\u5b9a\u6027\u5728\u4ec0\u4e48\u60c5\u51b5\u4e0b\u662f\u5fc5\u9700\u7684\uff1f

    \u5728\u73b0\u5b9e\u4e2d\uff0c\u6211\u4eec\u6709\u53ef\u80fd\u57fa\u4e8e\u5bf9\u8c61\u7684\u67d0\u4e2a\u5c5e\u6027\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\uff1a\u5148\u6309\u7167\u59d3\u540d\u8fdb\u884c\u6392\u5e8f\uff0c\u5f97\u5230 (A, 180) (B, 185) (C, 170) (D, 170) \uff1b\u518d\u5bf9\u8eab\u9ad8\u8fdb\u884c\u6392\u5e8f\u3002\u7531\u4e8e\u6392\u5e8f\u7b97\u6cd5\u4e0d\u7a33\u5b9a\uff0c\u56e0\u6b64\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

    Q\uff1a\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\u5927\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

    Q\uff1a\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\u957f\u5ea6\u7684\u4e00\u534a\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\\)\u3001\\(n - 1\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \uff0c\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \u3002\u5c3e\u9012\u5f52\u4f18\u5316\u53ef\u4ee5\u907f\u514d\u8fd9\u79cd\u60c5\u51b5\u51fa\u73b0\u3002

    Q\uff1a\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\u5bf9\u4e8e\u8fd9\u79cd\u60c5\u51b5\uff0c\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

    Q\uff1a\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":"\u7b2c 5 \u7ae0 \u00a0 \u6808\u4e0e\u961f\u5217","text":"

    Abstract

    \u6808\u5982\u540c\u53e0\u732b\u732b\uff0c\u800c\u961f\u5217\u5c31\u50cf\u732b\u732b\u6392\u961f\u3002

    \u4e24\u8005\u5206\u522b\u4ee3\u8868\u5148\u5165\u540e\u51fa\u548c\u5148\u5165\u5148\u51fa\u7684\u903b\u8f91\u5173\u7cfb\u3002

    "},{"location":"chapter_stack_and_queue/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 5.1 \u00a0 \u6808
    • 5.2 \u00a0 \u961f\u5217
    • 5.3 \u00a0 \u53cc\u5411\u961f\u5217
    • 5.4 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_stack_and_queue/deque/","title":"5.3 \u00a0 \u53cc\u5411\u961f\u5217","text":"

    \u5728\u961f\u5217\u4e2d\uff0c\u6211\u4eec\u4ec5\u80fd\u5220\u9664\u5934\u90e8\u5143\u7d20\u6216\u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\u3002\u5982\u56fe 5-7 \u6240\u793a\uff0c\u300c\u53cc\u5411\u961f\u5217 double-ended queue\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

    \u56fe 5-7 \u00a0 \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\u8868 5-3 \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

    \u8868 5-3 \u00a0 \u53cc\u5411\u961f\u5217\u64cd\u4f5c\u6548\u7387

    \u65b9\u6cd5\u540d \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 push_first() \u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u9996 \\(O(1)\\) push_last() \u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u5c3e \\(O(1)\\) pop_first() \u5220\u9664\u961f\u9996\u5143\u7d20 \\(O(1)\\) pop_last() \u5220\u9664\u961f\u5c3e\u5143\u7d20 \\(O(1)\\) peek_first() \u8bbf\u95ee\u961f\u9996\u5143\u7d20 \\(O(1)\\) peek_last() \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig deque.py
    from collections import deque\n\n# \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217\ndeque: deque[int] = deque()\n\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\n# \u8bbf\u95ee\u5143\u7d20\nfront: int = deque[0]  # \u961f\u9996\u5143\u7d20\nrear: int = deque[-1]  # \u961f\u5c3e\u5143\u7d20\n\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\n# \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nsize: int = len(deque)\n\n# \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(deque) == 0\n
    deque.cpp
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\ndeque<int> deque;\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nint front = deque.front(); // \u961f\u9996\u5143\u7d20\nint back = deque.back();   // \u961f\u5c3e\u5143\u7d20\n\n/* \u5143\u7d20\u51fa\u961f */\ndeque.pop_front();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.pop_back();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.size();\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty = deque.empty();\n
    deque.java
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\nDeque<Integer> deque = new LinkedList<>();\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.peekFirst();  // \u961f\u9996\u5143\u7d20\nint peekLast = deque.peekLast();    // \u961f\u5c3e\u5143\u7d20\n\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\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.size();\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = deque.isEmpty();\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();\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.First.Value;  // \u961f\u9996\u5143\u7d20\nint peekLast = deque.Last.Value;    // \u961f\u5c3e\u5143\u7d20\n\n/* \u5143\u7d20\u51fa\u961f */\ndeque.RemoveFirst();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.RemoveLast();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.Count;\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = deque.Count == 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\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nfront := deque.Front() // \u961f\u9996\u5143\u7d20\nrear := deque.Back()   // \u961f\u5c3e\u5143\u7d20\n\n/* \u5143\u7d20\u51fa\u961f */\ndeque.Remove(front)    // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.Remove(rear)     // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize := deque.Len()\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty := deque.Len() == 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\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nlet peekFirst = deque.first! // \u961f\u9996\u5143\u7d20\nlet peekLast = deque.last! // \u961f\u5c3e\u5143\u7d20\n\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\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = deque.count\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = deque.isEmpty\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\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);\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\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();\nconst popBack = deque.pop();\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = deque.length;\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst isEmpty = size === 0;\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\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);\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\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;\nconst popBack: number = deque.pop() as number;\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nconst size: number = deque.length;\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst isEmpty: boolean = size === 0;\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\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.first; // \u961f\u9996\u5143\u7d20\nint peekLast = deque.last;   // \u961f\u5c3e\u5143\u7d20\n\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\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.length;\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = deque.isEmpty;\n
    deque.rs
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\nlet mut deque: VecDeque<u32> = VecDeque::new();\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nif let Some(front) = deque.front() { // \u961f\u9996\u5143\u7d20\n}\nif let Some(rear) = deque.back() {   // \u961f\u5c3e\u5143\u7d20\n}\n\n/* \u5143\u7d20\u51fa\u961f */\nif let Some(pop_front) = deque.pop_front() { // \u961f\u9996\u5143\u7d20\u51fa\u961f\n}\nif let Some(pop_rear) = deque.pop_back() {   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = deque.len();\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = deque.is_empty();\n
    deque.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u53cc\u5411\u961f\u5217\n
    deque.kt
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\nval deque = LinkedList<Int>()\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nval peekFirst = deque.peekFirst() // \u961f\u9996\u5143\u7d20\nval peekLast = deque.peekLast()   // \u961f\u5c3e\u5143\u7d20\n\n/* \u5143\u7d20\u51fa\u961f */\nval popFirst = deque.pollFirst() // \u961f\u9996\u5143\u7d20\u51fa\u961f\nval popLast = deque.pollLast()   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nval size = deque.size\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = deque.isEmpty()\n
    deque.rb
    \n
    deque.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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":"1. \u00a0 \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\u201c\u53cc\u5411\u94fe\u8868\u201d\u4f5c\u4e3a\u53cc\u5411\u961f\u5217\u7684\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u3002

    \u5982\u56fe 5-8 \u6240\u793a\uff0c\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

    LinkedListDequepush_last()push_first()pop_last()pop_first()

    \u56fe 5-8 \u00a0 \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u53cc\u5411\u961f\u5217\u7684\u5165\u961f\u51fa\u961f\u64cd\u4f5c

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_deque.py
    class ListNode:\n    \"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n        self.prev: ListNode | None = None  # \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\nclass LinkedListDeque:\n    \"\"\"\u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._front: ListNode | None = None  # \u5934\u8282\u70b9 front\n        self._rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\n        self._size: int = 0  # \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self.size() == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"\u5165\u961f\u64cd\u4f5c\"\"\"\n        node = ListNode(num)\n        # \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if self.is_empty():\n            self._front = self._rear = node\n        # \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        elif is_front:\n            # \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            self._front.prev = node\n            node.next = self._front\n            self._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\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # \u66f4\u65b0\u5c3e\u8282\u70b9\n        self._size += 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n\n    def push_first(self, num: int):\n        \"\"\"\u961f\u9996\u5165\u961f\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -> int:\n        \"\"\"\u51fa\u961f\u64cd\u4f5c\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        # \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if is_front:\n            val: int = self._front.val  # \u6682\u5b58\u5934\u8282\u70b9\u503c\n            # \u5220\u9664\u5934\u8282\u70b9\n            fnext: ListNode | None = self._front.next\n            if fnext != None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # \u66f4\u65b0\u5934\u8282\u70b9\n        # \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else:\n            val: int = self._rear.val  # \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            # \u5220\u9664\u5c3e\u8282\u70b9\n            rprev: ListNode | None = self._rear.prev\n            if rprev != None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # \u66f4\u65b0\u5c3e\u8282\u70b9\n        self._size -= 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val\n\n    def pop_first(self) -> int:\n        \"\"\"\u961f\u9996\u51fa\u961f\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -> int:\n        \"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._front.val\n\n    def peek_last(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._rear.val\n\n    def to_array(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n
    linkedlist_deque.cpp
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nstruct DoublyListNode {\n    int val;              // \u8282\u70b9\u503c\n    DoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n    DoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\u6307\u9488\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize = 0;              // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~LinkedListDeque() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur->next;\n            delete pre;\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty())\n            front = rear = node;\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front->prev = node;\n            node->next = front;\n            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\n            rear->next = node;\n            node->prev = rear;\n            rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        int val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front->val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            DoublyListNode *fNext = front->next;\n            if (fNext != nullptr) {\n                fNext->prev = nullptr;\n                front->next = nullptr;\n            }\n            delete front;\n            front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            val = rear->val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            DoublyListNode *rPrev = rear->prev;\n            if (rPrev != nullptr) {\n                rPrev->next = nullptr;\n                rear->prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return front->val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return rear->val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        DoublyListNode *node = front;\n        vector<int> res(size());\n        for (int i = 0; i < res.size(); i++) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_deque.java
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    int val; // \u8282\u70b9\u503c\n    ListNode next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    ListNode prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private int queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty())\n            front = rear = node;\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front.prev = node;\n            node.next = front;\n            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\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            val = rear.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_deque.cs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode(int val) {\n    public int val = val;       // \u8282\u70b9\u503c\n    public ListNode? next = null; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    public ListNode? prev = null; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    ListNode? front, rear; // \u5934\u8282\u70b9 front, \u5c3e\u8282\u70b9 rear\n    int queSize = 0;      // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front!.prev = node;\n            node.next = front;\n            front = node; // \u66f4\u65b0\u5934\u8282\u70b9                           \n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front?.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            val = rear?.val;  // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i < res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u53cc\u7aef\u961f\u5217 */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* \u961f\u9996\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* \u961f\u5c3e\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* \u961f\u9996\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u961f\u5c3e\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n
    linkedlist_deque.swift
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    var val: Int // \u8282\u70b9\u503c\n    var next: ListNode? // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    weak var prev: ListNode? // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private var front: ListNode? // \u5934\u8282\u70b9 front\n    private var rear: ListNode? // \u5c3e\u8282\u70b9 rear\n    private var _size: Int // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if isFront {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front?.prev = node\n            node.next = front\n            front = node // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            rear?.next = node\n            node.prev = rear\n            rear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        _size += 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    private func pop(isFront: Bool) -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        let val: Int\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if isFront {\n            val = front!.val // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            val = rear!.val // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        _size -= 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    func popFirst() -> Int {\n        pop(isFront: true)\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    func popLast() -> Int {\n        pop(isFront: false)\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peekFirst() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return front!.val\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    func peekLast() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return rear!.val\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    func toArray() -> [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n
    linkedlist_deque.js
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    val; // \u8282\u70b9\u503c\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\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\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        this.#queSize++;\n    }\n\n    /* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        this.#queSize++;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5c3e\u8282\u70b9\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        this.#queSize--;\n        return value;\n    }\n\n    /* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5934\u8282\u70b9\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\n        this.#queSize--;\n        return value;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u6253\u5370\u53cc\u5411\u961f\u5217 */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n
    linkedlist_deque.ts
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    prev: ListNode; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    next: ListNode; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    val: number; // \u8282\u70b9\u503c\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private front: ListNode; // \u5934\u8282\u70b9 front\n    private rear: ListNode; // \u5c3e\u8282\u70b9 rear\n    private queSize: number; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        this.queSize++;\n    }\n\n    /* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        this.queSize++;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5c3e\u8282\u70b9\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        this.queSize--;\n        return value;\n    }\n\n    /* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5934\u8282\u70b9\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\n        this.queSize--;\n        return value;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u6253\u5370\u53cc\u5411\u961f\u5217 */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n
    linkedlist_deque.dart
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n  int val; // \u8282\u70b9\u503c\n  ListNode? next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n  ListNode? prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u5bf9\u5217 */\nclass LinkedListDeque {\n  late ListNode? _front; // \u5934\u8282\u70b9 _front\n  late ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\n  int _queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u957f\u5ea6 */\n  int size() {\n    return this._queSize;\n  }\n\n  /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* \u5165\u961f\u64cd\u4f5c */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 _front \u548c _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;\n      node.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;\n      node.prev = _rear;\n      _rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    _queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n  }\n\n  /* \u961f\u9996\u5165\u961f */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* \u961f\u5c3e\u5165\u961f */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* \u51fa\u961f\u64cd\u4f5c */\n  int? pop(bool isFront) {\n    // \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n      val = _front!.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n      // \u5220\u9664\u5934\u8282\u70b9\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n    } else {\n      // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n      val = _rear!.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n      // \u5220\u9664\u5c3e\u8282\u70b9\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    _queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    return val;\n  }\n\n  /* \u961f\u9996\u51fa\u961f */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* \u961f\u5c3e\u51fa\u961f */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n  List<int> toArray() {\n    ListNode? node = _front;\n    final List<int> res = [];\n    for (int i = 0; i < _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n
    linkedlist_deque.rs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\npub struct ListNode<T> {\n    pub val: T,                                 // \u8282\u70b9\u503c\n    pub next: Option<Rc<RefCell<ListNode<T>>>>, // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n    pub prev: Option<Rc<RefCell<ListNode<T>>>>, // \u524d\u9a71\u8282\u70b9\u6307\u9488\n}\n\nimpl<T> ListNode<T> {\n    pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\n#[allow(dead_code)]\npub struct LinkedListDeque<T> {\n    front: Option<Rc<RefCell<ListNode<T>>>>, // \u5934\u8282\u70b9 front\n    rear: Option<Rc<RefCell<ListNode<T>>>>,  // \u5c3e\u8282\u70b9 rear\n    que_size: usize,                         // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListDeque<T> {\n    pub fn new() -> Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.que_size;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    pub fn push(&mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        if is_front {\n            match self.front.take() {\n                // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n                None => {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n                Some(old_front) => {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // \u66f4\u65b0\u5934\u8282\u70b9\n                }\n            }\n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            match self.rear.take() {\n                // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n                None => {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n                Some(old_rear) => {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // \u66f4\u65b0\u5c3e\u8282\u70b9\n                }\n            }\n        }\n        self.que_size += 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pub fn push_first(&mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pub fn push_last(&mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    pub fn pop(&mut self, is_front: bool) -> Option<T> {\n        // \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de None\n        if self.is_empty() {\n            return None;\n        };\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) => {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // \u66f4\u65b0\u5934\u8282\u70b9\n                    }\n                    None => {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n                Rc::try_unwrap(old_front).ok().unwrap().into_inner().val\n            })\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) => {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // \u66f4\u65b0\u5c3e\u8282\u70b9\n                    }\n                    None => {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n                Rc::try_unwrap(old_rear).ok().unwrap().into_inner().val\n            })\n        }\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    pub fn pop_first(&mut self) -> Option<T> {\n        return self.pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    pub fn pop_last(&mut self) -> Option<T> {\n        return self.pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    pub fn peek_first(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.front.as_ref()\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    pub fn peek_last(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.rear.as_ref()\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.insert(0, node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_deque.c
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\ntypedef struct DoublyListNode {\n    int val;                     // \u8282\u70b9\u503c\n    struct DoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\n    struct DoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\n} DoublyListNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new->val = num;\n    new->next = NULL;\n    new->prev = NULL;\n    return new;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntypedef struct {\n    DoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize;                  // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n} LinkedListDeque;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque->front = NULL;\n    deque->rear = NULL;\n    deque->queSize = 0;\n    return deque;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // \u91ca\u653e\u6240\u6709\u8282\u70b9\n    for (int i = 0; i < deque->queSize && deque->front != NULL; i++) {\n        DoublyListNode *tmp = deque->front;\n        deque->front = deque->front->next;\n        free(tmp);\n    }\n    // \u91ca\u653e deque \u7ed3\u6784\u4f53\n    free(deque);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(LinkedListDeque *deque) {\n    return deque->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* \u5165\u961f */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411node\n    if (empty(deque)) {\n        deque->front = deque->rear = node;\n    }\n    // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n    else if (isFront) {\n        // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n        deque->front->prev = node;\n        node->next = deque->front;\n        deque->front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n    }\n    // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n    else {\n        // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n        deque->rear->next = node;\n        node->prev = deque->rear;\n        deque->rear = node;\n    }\n    deque->queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) && deque->front);\n    return deque->front->val;\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) && deque->rear);\n    return deque->rear->val;\n}\n\n/* \u51fa\u961f */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n    if (isFront) {\n        val = peekFirst(deque); // \u6682\u5b58\u5934\u8282\u70b9\u503c\n        DoublyListNode *fNext = deque->front->next;\n        if (fNext) {\n            fNext->prev = NULL;\n            deque->front->next = NULL;\n            delDoublyListNode(deque->front);\n        }\n        deque->front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n    }\n    // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n    else {\n        val = peekLast(deque); // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n        DoublyListNode *rPrev = deque->rear->prev;\n        if (rPrev) {\n            rPrev->next = NULL;\n            deque->rear->prev = NULL;\n            delDoublyListNode(deque->rear);\n        }\n        deque->rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    deque->queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    return val;\n}\n\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque->queSize);\n    // \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque->front; i < deque->queSize; i++) {\n        arr[i] = node->val;\n        node = node->next;\n    }\n    printArray(arr, deque->queSize);\n    free(arr);\n}\n
    linkedlist_deque.kt
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode(var value: Int) {\n    // \u8282\u70b9\u503c\n    var next: ListNode? = null // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    var prev: ListNode? = null // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private var front: ListNode? = null // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private var rear: ListNode? = null\n    private var queSize = 0 // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        } else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front?.prev = node\n            node.next = front\n            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\n            rear?.next = node\n            node.prev = rear\n            rear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++ // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n\n        val value: Int\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            value = front!!.value // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n            // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            value = rear!!.value // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize-- // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return value\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peekFirst(): Int {\n        if (isEmpty()) {\n            throw IndexOutOfBoundsException()\n\n        }\n        return front!!.value\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!.value\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!.value\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_deque.rb
    [class]{ListNode}-[func]{}\n\n[class]{LinkedListDeque}-[func]{}\n
    linkedlist_deque.zig
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\nfn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = undefined,     // \u8282\u70b9\u503c\n        next: ?*Self = null,    // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n        prev: ?*Self = null,    // \u524d\u9a71\u8282\u70b9\u6307\u9488\n\n        // Initialize a list node with specific value\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n            self.prev = null;\n        }\n    };\n}\n\n// \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\nfn LinkedListDeque(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        front: ?*ListNode(T) = null,                    // \u5934\u8282\u70b9 front\n        rear: ?*ListNode(T) = null,                     // \u5c3e\u8282\u70b9 rear\n        que_size: usize = 0,                             // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.front = null;\n            self.rear = null;\n            self.que_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.que_size;\n        }\n\n        // \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u5165\u961f\u64cd\u4f5c\n        pub fn push(self: *Self, num: T, is_front: bool) !void {\n            var node = try self.mem_allocator.create(ListNode(T));\n            node.init(num);\n            // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n            if (self.isEmpty()) {\n                self.front = node;\n                self.rear = node;\n            // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n            } else if (is_front) {\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n                self.front.?.prev = node;\n                node.next = self.front;\n                self.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\n                self.rear.?.next = node;\n                node.prev = self.rear;\n                self.rear = node;   // \u66f4\u65b0\u5c3e\u8282\u70b9\n            }\n            self.que_size += 1;      // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        } \n\n        // \u961f\u9996\u5165\u961f\n        pub fn pushFirst(self: *Self, num: T) !void {\n            try self.push(num, true);\n        } \n\n        // \u961f\u5c3e\u5165\u961f\n        pub fn pushLast(self: *Self, num: T) !void {\n            try self.push(num, false);\n        } \n\n        // \u51fa\u961f\u64cd\u4f5c\n        pub fn pop(self: *Self, is_front: bool) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            var val: T = undefined;\n            // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n            if (is_front) {\n                val = self.front.?.val;     // \u6682\u5b58\u5934\u8282\u70b9\u503c\n                // \u5220\u9664\u5934\u8282\u70b9\n                var fNext = self.front.?.next;\n                if (fNext != null) {\n                    fNext.?.prev = null;\n                    self.front.?.next = null;\n                }\n                self.front = fNext;         // \u66f4\u65b0\u5934\u8282\u70b9\n            // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n            } else {\n                val = self.rear.?.val;      // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n                // \u5220\u9664\u5c3e\u8282\u70b9\n                var rPrev = self.rear.?.prev;\n                if (rPrev != null) {\n                    rPrev.?.next = null;\n                    self.rear.?.prev = null;\n                }\n                self.rear = rPrev;          // \u66f4\u65b0\u5c3e\u8282\u70b9\n            }\n            self.que_size -= 1;              // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n            return val;\n        } \n\n        // \u961f\u9996\u51fa\u961f\n        pub fn popFirst(self: *Self) T {\n            return self.pop(true);\n        } \n\n        // \u961f\u5c3e\u51fa\u961f\n        pub fn popLast(self: *Self) T {\n            return self.pop(false);\n        } \n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peekFirst(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            return self.front.?.val;\n        }  \n\n        // \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\n        pub fn peekLast(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            return self.rear.?.val;\n        }\n\n        // \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.front;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[i] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    "},{"location":"chapter_stack_and_queue/deque/#2","title":"2. \u00a0 \u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u5982\u56fe 5-9 \u6240\u793a\uff0c\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

    ArrayDequepush_last()push_first()pop_last()pop_first()

    \u56fe 5-9 \u00a0 \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u53cc\u5411\u961f\u5217\u7684\u5165\u961f\u51fa\u961f\u64cd\u4f5c

    \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_deque.py
    class ArrayDeque:\n    \"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\n        return len(self._nums)\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._size == 0\n\n    def 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\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"\u961f\u9996\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        # \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        # \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        self._front = self.index(self._front - 1)\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        # \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        rear = self.index(self._front + self._size)\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -> int:\n        \"\"\"\u961f\u9996\u51fa\u961f\"\"\"\n        num = self.peek_first()\n        # \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -> int:\n        \"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._nums[self._front]\n\n    def peek_last(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        # \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def 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\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n
    array_deque.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n  private:\n    vector<int> nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;      // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    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\n        return (i + capacity()) % capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    int popFirst() {\n        int num = peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> res(queSize);\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n
    array_deque.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private int[] nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private 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\n        return (i + capacity()) % capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int popFirst() {\n        int num = peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    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\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = Index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntype arrayDeque struct {\n    nums        []int // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    queSize     int   // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n    queCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\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\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* \u961f\u9996\u5165\u961f */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n        return\n    }\n    // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n    q.front = q.index(q.front - 1)\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n        return\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    rear := q.index(q.front + q.queSize)\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* \u961f\u9996\u51fa\u961f */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    q.queSize--\n    return num\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\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\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i < q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n
    array_deque.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var _size: Int // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    func capacity() -> Int {\n        nums.count\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private 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\n    /* \u961f\u9996\u5165\u961f */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        front = index(i: front - 1)\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        nums[front] = num\n        _size += 1\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        let rear = index(i: front + size())\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    func popFirst() -> Int {\n        let num = peekFirst()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    func popLast() -> Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peekFirst() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return nums[front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    func peekLast() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    func toArray() -> [Int] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        (front ..< front + size()).map { nums[index(i: $0)] }\n    }\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\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    index(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\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        this.#front = this.index(this.#front - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        const rear = this.index(this.#front + this.#queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    popFirst() {\n        const num = this.peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const res = [];\n        for (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private queSize: number; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    index(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\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        this.front = this.index(this.front - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        const rear: number = this.index(this.front + this.queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    toArray(): number[] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i < this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n  late List<int> _nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n  late int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n  late int _queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n  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\n    return (i + capacity()) % capacity();\n  }\n\n  /* \u961f\u9996\u5165\u961f */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw 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\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\n  /* \u961f\u5c3e\u5165\u961f */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    int rear = index(_front + _queSize);\n    // \u5c06 _num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* \u961f\u9996\u51fa\u961f */\n  int popFirst() {\n    int _num = peekFirst();\n    // \u961f\u9996\u6307\u9488\u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* \u961f\u5c3e\u51fa\u961f */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n    }\n    return _nums[_front];\n  }\n\n  /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n    }\n    // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n  List<int> toArray() {\n    // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    List<int> res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i < _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n
    array_deque.rs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nstruct ArrayDeque {\n    nums: Vec<i32>,  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front: usize,    // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    que_size: usize, // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n}\n\nimpl ArrayDeque {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(capacity: usize) -> Self {\n        Self {\n            nums: vec![0; capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    pub fn capacity(&self) -> usize {\n        self.nums.len()\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        self.que_size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        self.que_size == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    fn index(&self, i: i32) -> usize {\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        return ((i + self.capacity() as i32) % self.capacity() as i32) as usize;\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pub fn push_first(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        self.front = self.index(self.front as i32 - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pub fn push_last(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fn pop_first(&mut self) -> i32 {\n        let num = self.peek_first();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    fn pop_last(&mut self) -> i32 {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fn peek_first(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        };\n        self.nums[self.front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fn peek_last(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        };\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fn to_array(&self) -> Vec<i32> {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        let mut res = vec![0; self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n
    array_deque.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntypedef struct {\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n} ArrayDeque;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // \u521d\u59cb\u5316\u6570\u7ec4\n    deque->queCapacity = capacity;\n    deque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);\n    deque->front = deque->queSize = 0;\n    return deque;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque->nums);\n    free(deque);\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(ArrayDeque *deque) {\n    return deque->queCapacity;\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size(ArrayDeque *deque) {\n    return deque->queSize;\n}\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(ArrayDeque *deque) {\n    return deque->queSize == 0;\n}\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\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque->queSize == capacity(deque)) {\n        printf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u56de\u5230\u5c3e\u90e8\n    deque->front = dequeIndex(deque, deque->front - 1);\n    // \u5c06 num \u6dfb\u52a0\u5230\u961f\u9996\n    deque->nums[deque->front] = num;\n    deque->queSize++;\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque->queSize == capacity(deque)) {\n        printf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    int rear = dequeIndex(deque, deque->front + deque->queSize);\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    deque->nums[rear] = num;\n    deque->queSize++;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(ArrayDeque *deque) {\n    // \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\n    assert(empty(deque) == 0);\n    return deque->nums[deque->front];\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(ArrayDeque *deque) {\n    // \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque->front + deque->queSize - 1);\n    return deque->nums[last];\n}\n\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    deque->front = dequeIndex(deque, deque->front + 1);\n    deque->queSize--;\n    return num;\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque->queSize--;\n    return num;\n}\n
    array_deque.kt
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque(capacity: Int) {\n    private var nums = IntArray(capacity) // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var queSize = 0 // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private fun 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        return (i + capacity()) % capacity()\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        val rear = index(front + queSize)\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        queSize++\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fun toArray(): IntArray {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i < queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n
    array_deque.rb
    [class]{ArrayDeque}-[func]{}\n
    array_deque.zig
    [class]{ArrayDeque}-[func]{}\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\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\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\u5c3e\u90e8\uff0c\u800c\u4f4d\u4e8e\u961f\u5217\u5934\u90e8\u7684\u4eba\u9010\u4e2a\u79bb\u5f00\u3002

    \u5982\u56fe 5-4 \u6240\u793a\uff0c\u6211\u4eec\u5c06\u961f\u5217\u5934\u90e8\u79f0\u4e3a\u201c\u961f\u9996\u201d\uff0c\u5c3e\u90e8\u79f0\u4e3a\u201c\u961f\u5c3e\u201d\uff0c\u5c06\u628a\u5143\u7d20\u52a0\u5165\u961f\u5c3e\u7684\u64cd\u4f5c\u79f0\u4e3a\u201c\u5165\u961f\u201d\uff0c\u5220\u9664\u961f\u9996\u5143\u7d20\u7684\u64cd\u4f5c\u79f0\u4e3a\u201c\u51fa\u961f\u201d\u3002

    \u56fe 5-4 \u00a0 \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\u8868 5-2 \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

    \u8868 5-2 \u00a0 \u961f\u5217\u64cd\u4f5c\u6548\u7387

    \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig queue.py
    from collections import deque\n\n# \u521d\u59cb\u5316\u961f\u5217\n# \u5728 Python \u4e2d\uff0c\u6211\u4eec\u4e00\u822c\u5c06\u53cc\u5411\u961f\u5217\u7c7b deque \u5f53\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\u63a8\u8350\nque: deque[int] = deque()\n\n# \u5143\u7d20\u5165\u961f\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# \u8bbf\u95ee\u961f\u9996\u5143\u7d20\nfront: int = que[0]\n\n# \u5143\u7d20\u51fa\u961f\npop: int = que.popleft()\n\n# \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\nsize: int = len(que)\n\n# \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(que) == 0\n
    queue.cpp
    /* \u521d\u59cb\u5316\u961f\u5217 */\nqueue<int> queue;\n\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint front = queue.front();\n\n/* \u5143\u7d20\u51fa\u961f */\nqueue.pop();\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.size();\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty = queue.empty();\n
    queue.java
    /* \u521d\u59cb\u5316\u961f\u5217 */\nQueue<Integer> queue = new LinkedList<>();\n\n/* \u5143\u7d20\u5165\u961f */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.peek();\n\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.poll();\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.size();\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = queue.isEmpty();\n
    queue.cs
    /* \u521d\u59cb\u5316\u961f\u5217 */\nQueue<int> queue = new();\n\n/* \u5143\u7d20\u5165\u961f */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.Peek();\n\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.Dequeue();\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.Count;\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = queue.Count == 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\n/* \u5143\u7d20\u5165\u961f */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek := queue.Front()\n\n/* \u5143\u7d20\u51fa\u961f */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nsize := queue.Len()\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty := queue.Len() == 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\n/* \u5143\u7d20\u5165\u961f */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nlet peek = queue.first!\n\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\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = queue.count\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = queue.isEmpty\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\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nconst peek = queue[0];\n\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\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = queue.length;\n\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\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nconst peek = queue[0];\n\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\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = queue.length;\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst empty = queue.length === 0;\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\n/* \u5143\u7d20\u5165\u961f */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.first;\n\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.removeFirst();\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.length;\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = queue.isEmpty;\n
    queue.rs
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// \u5728 Rust \u4e2d\u4f7f\u7528\u53cc\u5411\u961f\u5217\u4f5c\u4e3a\u666e\u901a\u961f\u5217\u6765\u4f7f\u7528\nlet mut deque: VecDeque<u32> = VecDeque::new();\n\n/* \u5143\u7d20\u5165\u961f */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nif let Some(front) = deque.front() {\n}\n\n/* \u5143\u7d20\u51fa\u961f */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = deque.len();\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = deque.is_empty();\n
    queue.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u961f\u5217\n
    queue.kt
    /* \u521d\u59cb\u5316\u961f\u5217 */\nval queue = LinkedList<Int>()\n\n/* \u5143\u7d20\u5165\u961f */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nval peek = queue.peek()\n\n/* \u5143\u7d20\u51fa\u961f */\nval pop = queue.poll()\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nval size = queue.size\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = queue.isEmpty()\n
    queue.rb
    \n
    queue.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\uff0c\u94fe\u8868\u548c\u6570\u7ec4\u90fd\u7b26\u5408\u8981\u6c42\u3002

    "},{"location":"chapter_stack_and_queue/queue/#1","title":"1. \u00a0 \u57fa\u4e8e\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u5982\u56fe 5-5 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u94fe\u8868\u7684\u201c\u5934\u8282\u70b9\u201d\u548c\u201c\u5c3e\u8282\u70b9\u201d\u5206\u522b\u89c6\u4e3a\u201c\u961f\u9996\u201d\u548c\u201c\u961f\u5c3e\u201d\uff0c\u89c4\u5b9a\u961f\u5c3e\u4ec5\u53ef\u6dfb\u52a0\u8282\u70b9\uff0c\u961f\u9996\u4ec5\u53ef\u5220\u9664\u8282\u70b9\u3002

    LinkedListQueuepush()pop()

    \u56fe 5-5 \u00a0 \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u961f\u5217\u7684\u5165\u961f\u51fa\u961f\u64cd\u4f5c

    \u4ee5\u4e0b\u662f\u7528\u94fe\u8868\u5b9e\u73b0\u961f\u5217\u7684\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_queue.py
    class LinkedListQueue:\n    \"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._front: ListNode | None = None  # \u5934\u8282\u70b9 front\n        self._rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\n        self._size: int = 0\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return not self._front\n\n    def push(self, num: int):\n        \"\"\"\u5165\u961f\"\"\"\n        # \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        node = ListNode(num)\n        # \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if self._front is None:\n            self._front = node\n            self._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:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u961f\"\"\"\n        num = self.peek()\n        # \u5220\u9664\u5934\u8282\u70b9\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\n        return self._front.val\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n
    linkedlist_queue.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        freeMemoryLinkedList(front);\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    void push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode *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\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n        else {\n            rear->next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    int pop() {\n        int num = peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        ListNode *tmp = front;\n        front = front->next;\n        // \u91ca\u653e\u5185\u5b58\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        return front->val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        ListNode *node = front;\n        vector<int> res(size());\n        for (int i = 0; i < res.size(); i++) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_queue.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f */\n    public void push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode 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\n        if (front == null) {\n            front = node;\n            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 {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int pop() {\n        int num = peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    ListNode? front, rear;  // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear \n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u961f */\n    public void Push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode node = new(num);\n        // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if (front == null) {\n            front = node;\n            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 if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int Pop() {\n        int num = Peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i < res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* \u5165\u961f */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* \u51fa\u961f */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n
    linkedlist_queue.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private var front: ListNode? // \u5934\u8282\u70b9\n    private var rear: ListNode? // \u5c3e\u8282\u70b9\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f */\n    func push(num: Int) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        let 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\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* \u51fa\u961f */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return front!.val\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\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;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        const 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\n        if (!this.#front) {\n            this.#front = node;\n            this.#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 {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop() {\n        const num = this.peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek() {\n        if (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.#front.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private front: ListNode | null; // \u5934\u8282\u70b9 front\n    private rear: ListNode | null; // \u5c3e\u8282\u70b9 rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num: number): void {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        const 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\n        if (!this.front) {\n            this.front = node;\n            this.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 {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        // \u5220\u9664\u5934\u8282\u70b9\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek(): number {\n        if (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.front!.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array<number>(this.size);\n        for (let i = 0; i < res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.dart
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n  ListNode? _front; // \u5934\u8282\u70b9 _front\n  ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\n  int _queSize = 0; // \u961f\u5217\u957f\u5ea6\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u5165\u961f */\n  void push(int _num) {\n    // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 _num\n    final node = ListNode(_num);\n    // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n    if (_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\n  /* \u51fa\u961f */\n  int pop() {\n    final int _num = peek();\n    // \u5220\u9664\u5934\u8282\u70b9\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('\u961f\u5217\u4e3a\u7a7a');\n    }\n    return _front!.val;\n  }\n\n  /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n  List<int> toArray() {\n    ListNode? node = _front;\n    final List<int> queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n
    linkedlist_queue.rs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\n#[allow(dead_code)]\npub struct LinkedListQueue<T> {\n    front: Option<Rc<RefCell<ListNode<T>>>>, // \u5934\u8282\u70b9 front\n    rear: Option<Rc<RefCell<ListNode<T>>>>,  // \u5c3e\u8282\u70b9 rear\n    que_size: usize,                         // \u961f\u5217\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListQueue<T> {\n    pub fn new() -> Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.que_size;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u961f */\n    pub fn push(&mut self, num: T) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n            Some(old_rear) => {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n            None => {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* \u51fa\u961f */\n    pub fn pop(&mut self) -> Option<T> {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) => {\n                    self.front = Some(new_front);\n                }\n                None => {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            Rc::try_unwrap(old_front).ok().unwrap().into_inner().val\n        })\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.front.as_ref()\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.insert(0, node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_queue.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue->front = NULL;\n    queue->rear = NULL;\n    queue->queSize = 0;\n    return queue;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // \u91ca\u653e\u6240\u6709\u8282\u70b9\n    while (queue->front != NULL) {\n        ListNode *tmp = queue->front;\n        queue->front = queue->front->next;\n        free(tmp);\n    }\n    // \u91ca\u653e queue \u7ed3\u6784\u4f53\n    free(queue);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(LinkedListQueue *queue) {\n    return queue->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* \u5165\u961f */\nvoid push(LinkedListQueue *queue, int num) {\n    // \u5c3e\u8282\u70b9\u5904\u6dfb\u52a0 node\n    ListNode *node = newListNode(num);\n    // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n    if (queue->front == NULL) {\n        queue->front = node;\n        queue->rear = node;\n    }\n    // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n    else {\n        queue->rear->next = node;\n        queue->rear = node;\n    }\n    queue->queSize++;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) && queue->front);\n    return queue->front->val;\n}\n\n/* \u51fa\u961f */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue->front;\n    queue->front = queue->front->next;\n    free(tmp);\n    queue->queSize--;\n    return num;\n}\n\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue->queSize);\n    // \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue->front; i < queue->queSize; i++) {\n        arr[i] = node->val;\n        node = node->next;\n    }\n    printArray(arr, queue->queSize);\n    free(arr);\n}\n
    linkedlist_queue.kt
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue(\n    // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u961f */\n    fun push(num: Int) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        val node = ListNode(num)\n        // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if (front == null) {\n            front = node\n            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 {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* \u51fa\u961f */\n    fun pop(): Int {\n        val num = peek()\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!.value\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!.value\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_queue.rb
    [class]{LinkedListQueue}-[func]{}\n
    linkedlist_queue.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\nfn LinkedListQueue(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        front: ?*inc.ListNode(T) = null,                // \u5934\u8282\u70b9 front\n        rear: ?*inc.ListNode(T) = null,                 // \u5c3e\u8282\u70b9 rear\n        que_size: usize = 0,                            // \u961f\u5217\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.front = null;\n            self.rear = null;\n            self.que_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.que_size;\n        }\n\n        // \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.size() == 0) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\n            return self.front.?.val;\n        }  \n\n        // \u5165\u961f\n        pub fn push(self: *Self, num: T) !void {\n            // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n            var node = try self.mem_allocator.create(inc.ListNode(T));\n            node.init(num);\n            // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n            if (self.front == null) {\n                self.front = node;\n                self.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 {\n                self.rear.?.next = node;\n                self.rear = node;\n            }\n            self.que_size += 1;\n        } \n\n        // \u51fa\u961f\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            // \u5220\u9664\u5934\u8282\u70b9\n            self.front = self.front.?.next;\n            self.que_size -= 1;\n            return num;\n        } \n\n        // \u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.front;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[i] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_stack_and_queue/queue/#2","title":"2. \u00a0 \u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u5728\u6570\u7ec4\u4e2d\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 size \u7528\u4e8e\u8bb0\u5f55\u961f\u5217\u957f\u5ea6\u3002\u5b9a\u4e49 rear = front + size \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\u5404\u79cd\u64cd\u4f5c\u7684\u5b9e\u73b0\u65b9\u6cd5\u5982\u56fe 5-6 \u6240\u793a\u3002

    • \u5165\u961f\u64cd\u4f5c\uff1a\u5c06\u8f93\u5165\u5143\u7d20\u8d4b\u503c\u7ed9 rear \u7d22\u5f15\u5904\uff0c\u5e76\u5c06 size \u589e\u52a0 1 \u3002
    • \u51fa\u961f\u64cd\u4f5c\uff1a\u53ea\u9700\u5c06 front \u589e\u52a0 1 \uff0c\u5e76\u5c06 size \u51cf\u5c11 1 \u3002

    \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()

    \u56fe 5-6 \u00a0 \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u961f\u5217\u7684\u5165\u961f\u51fa\u961f\u64cd\u4f5c

    \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\u4e86\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u89c6\u4e3a\u9996\u5c3e\u76f8\u63a5\u7684\u201c\u73af\u5f62\u6570\u7ec4\u201d\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_queue.py
    class ArrayQueue:\n    \"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._nums: list[int] = [0] * size  # \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n        self._front: int = 0  # \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n        self._size: int = 0  # \u961f\u5217\u957f\u5ea6\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\n        return len(self._nums)\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"\u961f\u5217\u5df2\u6ee1\")\n        # \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        # \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        rear: int = (self._front + self._size) % self.capacity()\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u961f\"\"\"\n        num: int = self.peek()\n        # \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\n        return self._nums[self._front]\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n
    array_queue.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n  private:\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u961f\u5217\u957f\u5ea6\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n\n  public:\n    ArrayQueue(int capacity) {\n        // \u521d\u59cb\u5316\u6570\u7ec4\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout << \"\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % queCapacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    int pop() {\n        int num = peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        return nums[front];\n    }\n\n    /* \u5c06\u6570\u7ec4\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> arr(queSize);\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n
    array_queue.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private int[] nums; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private int queSize; // \u961f\u5217\u957f\u5ea6\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % capacity();\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int pop() {\n        int num = peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    public int[] toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n
    array_queue.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize; // \u961f\u5217\u957f\u5ea6\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % Capacity();\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int Pop() {\n        int num = Peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n
    array_queue.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntype arrayQueue struct {\n    nums        []int // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    queSize     int   // \u961f\u5217\u957f\u5ea6\n    queCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* \u5165\u961f */\nfunc (q *arrayQueue) push(num int) {\n    // \u5f53 rear == queCapacity \u8868\u793a\u961f\u5217\u5df2\u6ee1\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    rear := (q.front + q.queSize) % q.queCapacity\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* \u51fa\u961f */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear >= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n
    array_queue.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var _size: Int // \u961f\u5217\u957f\u5ea6\n\n    init(capacity: Int) {\n        // \u521d\u59cb\u5316\u6570\u7ec4\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    func capacity() -> Int {\n        nums.count\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        let rear = (front + size()) % capacity()\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* \u51fa\u961f */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return nums[front]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    func toArray() -> [Int] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        (front ..< front + size()).map { nums[$0 % capacity()] }\n    }\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\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        const rear = (this.#front + this.size) % this.capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop() {\n        const num = this.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek() {\n        if (this.isEmpty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.#nums[this.#front];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i < this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n
    array_queue.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private queSize: number; // \u961f\u5217\u957f\u5ea6\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        const rear = (this.front + this.queSize) % this.capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop(): number {\n        const num = this.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.nums[this.front];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray(): number[] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i < this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n
    array_queue.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n  late List<int> _nums; // \u7528\u4e8e\u50a8\u5b58\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n  late int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n  late int _queSize; // \u961f\u5217\u957f\u5ea6\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u5165\u961f */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"\u961f\u5217\u5df2\u6ee1\");\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    int rear = (_front + _queSize) % capaCity();\n    // \u5c06 _num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* \u51fa\u961f */\n  int pop() {\n    int _num = peek();\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"\u961f\u5217\u4e3a\u7a7a\");\n    }\n    return _nums[_front];\n  }\n\n  /* \u8fd4\u56de Array */\n  List<int> toArray() {\n    // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    final List<int> res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i < _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n
    array_queue.rs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nstruct ArrayQueue {\n    nums: Vec<i32>,    // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front: i32,        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    que_size: i32,     // \u961f\u5217\u957f\u5ea6\n    que_capacity: i32, // \u961f\u5217\u5bb9\u91cf\n}\n\nimpl ArrayQueue {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(capacity: i32) -> ArrayQueue {\n        ArrayQueue {\n            nums: vec![0; capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    fn capacity(&self) -> i32 {\n        self.que_capacity\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fn size(&self) -> i32 {\n        self.que_size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fn is_empty(&self) -> bool {\n        self.que_size == 0\n    }\n\n    /* \u5165\u961f */\n    fn push(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* \u51fa\u961f */\n    fn pop(&mut self) -> i32 {\n        let num = self.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fn peek(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    fn to_vector(&self) -> Vec<i32> {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![0; self.que_size as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n
    array_queue.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntypedef struct {\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n} ArrayQueue;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // \u521d\u59cb\u5316\u6570\u7ec4\n    queue->queCapacity = capacity;\n    queue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);\n    queue->front = queue->queSize = 0;\n    return queue;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue->nums);\n    free(queue);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(ArrayQueue *queue) {\n    return queue->queCapacity;\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(ArrayQueue *queue) {\n    return queue->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(ArrayQueue *queue) {\n    return queue->queSize == 0;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue->nums[queue->front];\n}\n\n/* \u5165\u961f */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    int rear = (queue->front + queue->queSize) % queue->queCapacity;\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    queue->nums[rear] = num;\n    queue->queSize++;\n}\n\n/* \u51fa\u961f */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    queue->front = (queue->front + 1) % queue->queCapacity;\n    queue->queSize--;\n    return num;\n}\n
    array_queue.kt
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue(capacity: Int) {\n    private val nums = IntArray(capacity) // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var queSize = 0 // \u961f\u5217\u957f\u5ea6\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* \u5165\u961f */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        val rear = (front + queSize) % capacity()\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        queSize++\n    }\n\n    /* \u51fa\u961f */\n    fun pop(): Int {\n        val num = peek()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    fun toArray(): IntArray {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i < queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n
    array_queue.rb
    [class]{ArrayQueue}-[func]{}\n
    array_queue.zig
    // \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\nfn ArrayQueue(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        nums: []T = undefined,                          // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4     \n        cap: usize = 0,                                 // \u961f\u5217\u5bb9\u91cf\n        front: usize = 0,                               // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n        queSize: usize = 0,                             // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6570\u7ec4\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.cap = cap;\n            self.nums = try self.mem_allocator.alloc(T, self.cap);\n            @memset(self.nums, @as(T, 0));\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\n        pub fn capacity(self: *Self) usize {\n            return self.cap;\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.queSize;\n        }\n\n        // \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.queSize == 0;\n        }\n\n        // \u5165\u961f\n        pub fn push(self: *Self, num: T) !void {\n            if (self.size() == self.capacity()) {\n                std.debug.print(\"\u961f\u5217\u5df2\u6ee1\\n\", .{});\n                return;\n            }\n            // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n            // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n            var rear = (self.front + self.queSize) % self.capacity();\n            // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n            self.nums[rear] = num;\n            self.queSize += 1;\n        } \n\n        // \u51fa\u961f\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n            self.front = (self.front + 1) % self.capacity();\n            self.queSize -= 1;\n            return num;\n        } \n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\n            return self.nums[self.front];\n        } \n\n        // \u8fd4\u56de\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            var j: usize = self.front;\n            while (i < self.size()) : ({ i += 1; j += 1; }) {\n                res[i] = self.nums[j % self.capacity()];\n            }\n            return res;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u4ee5\u4e0a\u5b9e\u73b0\u7684\u961f\u5217\u4ecd\u7136\u5177\u6709\u5c40\u9650\u6027\uff1a\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\u8bfb\u8005\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\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\uff0c\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\u903b\u8f91\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\u60f3\u53d6\u51fa\u5e95\u90e8\u7684\u76d8\u5b50\uff0c\u5219\u9700\u8981\u5148\u5c06\u4e0a\u9762\u7684\u76d8\u5b50\u4f9d\u6b21\u79fb\u8d70\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\u8fd9\u79cd\u6570\u636e\u7ed3\u6784\u3002

    \u5982\u56fe 5-1 \u6240\u793a\uff0c\u6211\u4eec\u628a\u5806\u53e0\u5143\u7d20\u7684\u9876\u90e8\u79f0\u4e3a\u201c\u6808\u9876\u201d\uff0c\u5e95\u90e8\u79f0\u4e3a\u201c\u6808\u5e95\u201d\u3002\u5c06\u628a\u5143\u7d20\u6dfb\u52a0\u5230\u6808\u9876\u7684\u64cd\u4f5c\u53eb\u4f5c\u201c\u5165\u6808\u201d\uff0c\u5220\u9664\u6808\u9876\u5143\u7d20\u7684\u64cd\u4f5c\u53eb\u4f5c\u201c\u51fa\u6808\u201d\u3002

    \u56fe 5-1 \u00a0 \u6808\u7684\u5148\u5165\u540e\u51fa\u89c4\u5219

    "},{"location":"chapter_stack_and_queue/stack/#511","title":"5.1.1 \u00a0 \u6808\u7684\u5e38\u7528\u64cd\u4f5c","text":"

    \u6808\u7684\u5e38\u7528\u64cd\u4f5c\u5982\u8868 5-1 \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()\u3001pop()\u3001peek() \u547d\u540d\u4e3a\u4f8b\u3002

    \u8868 5-1 \u00a0 \u6808\u7684\u64cd\u4f5c\u6548\u7387

    \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\u201c\u6570\u7ec4\u201d\u6216\u201c\u94fe\u8868\u201d\u5f53\u4f5c\u6808\u6765\u4f7f\u7528\uff0c\u5e76\u5728\u7a0b\u5e8f\u903b\u8f91\u4e0a\u5ffd\u7565\u4e0e\u6808\u65e0\u5173\u7684\u64cd\u4f5c\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n# \u5143\u7d20\u5165\u6808\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# \u8bbf\u95ee\u6808\u9876\u5143\u7d20\npeek: int = stack[-1]\n\n# \u5143\u7d20\u51fa\u6808\npop: int = stack.pop()\n\n# \u83b7\u53d6\u6808\u7684\u957f\u5ea6\nsize: int = len(stack)\n\n# \u5224\u65ad\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(stack) == 0\n
    stack.cpp
    /* \u521d\u59cb\u5316\u6808 */\nstack<int> stack;\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint top = stack.top();\n\n/* \u5143\u7d20\u51fa\u6808 */\nstack.pop(); // \u65e0\u8fd4\u56de\u503c\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.size();\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool empty = stack.empty();\n
    stack.java
    /* \u521d\u59cb\u5316\u6808 */\nStack<Integer> stack = new Stack<>();\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.peek();\n\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.pop();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.size();\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = stack.isEmpty();\n
    stack.cs
    /* \u521d\u59cb\u5316\u6808 */\nStack<int> stack = new();\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.Peek();\n\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.Pop();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.Count;\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = stack.Count == 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\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\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npeek := stack[len(stack)-1]\n\n/* \u5143\u7d20\u51fa\u6808 */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nsize := len(stack)\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nisEmpty := len(stack) == 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\n/* \u5143\u7d20\u5165\u6808 */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nlet peek = stack.last!\n\n/* \u5143\u7d20\u51fa\u6808 */\nlet pop = stack.removeLast()\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nlet size = stack.count\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = stack.isEmpty\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\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nconst peek = stack[stack.length-1];\n\n/* \u5143\u7d20\u51fa\u6808 */\nconst pop = stack.pop();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nconst size = stack.length;\n\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\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nconst peek = stack[stack.length - 1];\n\n/* \u5143\u7d20\u51fa\u6808 */\nconst pop = stack.pop();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nconst size = stack.length;\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nconst is_empty = stack.length === 0;\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\n/* \u5143\u7d20\u5165\u6808 */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.last;\n\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.removeLast();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.length;\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = stack.isEmpty;\n
    stack.rs
    /* \u521d\u59cb\u5316\u6808 */\n// \u628a Vec \u5f53\u4f5c\u6808\u6765\u4f7f\u7528\nlet mut stack: Vec<i32> = Vec::new();\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nlet top = stack.last().unwrap();\n\n/* \u5143\u7d20\u51fa\u6808 */\nlet pop = stack.pop().unwrap();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nlet size = stack.len();\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = stack.is_empty();\n
    stack.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u6808\n
    stack.kt
    /* \u521d\u59cb\u5316\u6808 */\nval stack = Stack<Int>()\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nval peek = stack.peek()\n\n/* \u5143\u7d20\u51fa\u6808 */\nval pop = stack.pop()\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nval size = stack.size\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = stack.isEmpty()\n
    stack.rb
    \n
    stack.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\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":"1. \u00a0 \u57fa\u4e8e\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u4f7f\u7528\u94fe\u8868\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

    \u5982\u56fe 5-2 \u6240\u793a\uff0c\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()

    \u56fe 5-2 \u00a0 \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u6808\u7684\u5165\u6808\u51fa\u6808\u64cd\u4f5c

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u6808\u7684\u793a\u4f8b\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_stack.py
    class LinkedListStack:\n    \"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return not self._peek\n\n    def push(self, val: int):\n        \"\"\"\u5165\u6808\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u6808\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._peek.val\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n
    linkedlist_stack.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int stkSize;        // \u6808\u7684\u957f\u5ea6\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    int size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node->next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop->next;\n        // \u91ca\u653e\u5185\u5b58\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"\u6808\u4e3a\u7a7a\");\n        return stackTop->val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        ListNode *node = stackTop;\n        vector<int> res(size());\n        for (int i = res.size() - 1; i >= 0; i--) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_stack.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private ListNode stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private int stkSize = 0; // \u6808\u7684\u957f\u5ea6\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i >= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    ListNode? stackPeek;  // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int stkSize = 0;   // \u6808\u7684\u957f\u5ea6\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i >= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u6808 */\nfunc newLinkedListStack() *linkedListStack {\n    return &linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* \u5165\u6808 */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* \u51fa\u6808 */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n
    linkedlist_stack.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private var _peek: ListNode? // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private var _size: Int // \u6808\u7684\u957f\u5ea6\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u6808 */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* \u51fa\u6808 */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return _peek!.val\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\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\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    peek() {\n        if (!this.#stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stackPeek.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i >= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private stkSize: number = 0; // \u6808\u7684\u957f\u5ea6\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stackPeek.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array<number>(this.size);\n        for (let i = res.length - 1; i >= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.dart
    /* \u57fa\u4e8e\u94fe\u8868\u7c7b\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n  ListNode? _stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n  int _stkSize = 0; // \u6808\u7684\u957f\u5ea6\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n  int size() {\n    return _stkSize;\n  }\n\n  /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* \u5165\u6808 */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* \u51fa\u6808 */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a List \u5e76\u8fd4\u56de */\n  List<int> toList() {\n    ListNode? node = _stackPeek;\n    List<int> list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n
    linkedlist_stack.rs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\n#[allow(dead_code)]\npub struct LinkedListStack<T> {\n    stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    stk_size: usize,                              // \u6808\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListStack<T> {\n    pub fn new() -> Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.stk_size;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    pub fn push(&mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* \u51fa\u6808 */\n    pub fn pop(&mut self) -> Option<T> {\n        self.stack_peek.take().map(|old_head| {\n            match old_head.borrow_mut().next.take() {\n                Some(new_head) => {\n                    self.stack_peek = Some(new_head);\n                }\n                None => {\n                    self.stack_peek = None;\n                }\n            }\n            self.stk_size -= 1;\n            Rc::try_unwrap(old_head).ok().unwrap().into_inner().val\n        })\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.stack_peek.as_ref()\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.push(node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_stack.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\ntypedef struct {\n    ListNode *top; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int size;      // \u6808\u7684\u957f\u5ea6\n} LinkedListStack;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s->top = NULL;\n    s->size = 0;\n    return s;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s->top) {\n        ListNode *n = s->top->next;\n        free(s->top);\n        s->top = n;\n    }\n    free(s);\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(LinkedListStack *s) {\n    return s->size;\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* \u5165\u6808 */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node->next = s->top; // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6307\u9488\u57df\n    node->val = num;     // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6570\u636e\u57df\n    s->top = node;       // \u66f4\u65b0\u6808\u9876\n    s->size++;           // \u66f4\u65b0\u6808\u5927\u5c0f\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(LinkedListStack *s) {\n    if (s->size == 0) {\n        printf(\"\u6808\u4e3a\u7a7a\\n\");\n        return INT_MAX;\n    }\n    return s->top->val;\n}\n\n/* \u51fa\u6808 */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s->top;\n    s->top = s->top->next;\n    // \u91ca\u653e\u5185\u5b58\n    free(tmp);\n    s->size--;\n    return val;\n}\n
    linkedlist_stack.kt
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private var stkSize: Int = 0 // \u6808\u7684\u957f\u5ea6\n) {\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* \u51fa\u6808 */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--;\n        return num\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?.value\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?.value!!\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_stack.rb
    [class]{LinkedListStack}-[func]{}\n
    linkedlist_stack.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\nfn LinkedListStack(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        stack_top: ?*inc.ListNode(T) = null,             // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n        stk_size: usize = 0,                             // \u6808\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,    // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.stack_top = null;\n            self.stk_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u6808\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.stk_size;\n        }\n\n        // \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u6808\u9876\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.size() == 0) @panic(\"\u6808\u4e3a\u7a7a\");\n            return self.stack_top.?.val;\n        }  \n\n        // \u5165\u6808\n        pub fn push(self: *Self, num: T) !void {\n            var node = try self.mem_allocator.create(inc.ListNode(T));\n            node.init(num);\n            node.next = self.stack_top;\n            self.stack_top = node;\n            self.stk_size += 1;\n        } \n\n        // \u51fa\u6808\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            self.stack_top = self.stack_top.?.next;\n            self.stk_size -= 1;\n            return num;\n        } \n\n        // \u5c06\u6808\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.stack_top;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[res.len - i - 1] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_stack_and_queue/stack/#2","title":"2. \u00a0 \u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u4f7f\u7528\u6570\u7ec4\u5b9e\u73b0\u6808\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u7684\u5c3e\u90e8\u4f5c\u4e3a\u6808\u9876\u3002\u5982\u56fe 5-3 \u6240\u793a\uff0c\u5165\u6808\u4e0e\u51fa\u6808\u64cd\u4f5c\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()

    \u56fe 5-3 \u00a0 \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u6808\u7684\u5165\u6808\u51fa\u6808\u64cd\u4f5c

    \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\u987b\u81ea\u884c\u5904\u7406\u6570\u7ec4\u6269\u5bb9\u95ee\u9898\u3002\u4ee5\u4e0b\u4e3a\u793a\u4f8b\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_stack.py
    class ArrayStack:\n    \"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._stack == []\n\n    def push(self, item: int):\n        \"\"\"\u5165\u6808\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u6808\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._stack.pop()\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._stack[-1]\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        return self._stack\n
    array_stack.cpp
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n  private:\n    vector<int> stack;\n\n  public:\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    int size() {\n        return stack.size();\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* \u51fa\u6808 */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"\u6808\u4e3a\u7a7a\");\n        return stack.back();\n    }\n\n    /* \u8fd4\u56de Vector */\n    vector<int> toVector() {\n        return stack;\n    }\n};\n
    array_stack.java
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private ArrayList<Integer> stack;\n\n    public ArrayStack() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = new ArrayList<>();\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int size() {\n        return stack.size();\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* \u51fa\u6808 */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n
    array_stack.cs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    List<int> stack;\n    public ArrayStack() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* \u51fa\u6808 */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n
    array_stack.go
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntype arrayStack struct {\n    data []int // \u6570\u636e\n}\n\n/* \u521d\u59cb\u5316\u6808 */\nfunc newArrayStack() *arrayStack {\n    return &arrayStack{\n        // \u8bbe\u7f6e\u6808\u7684\u957f\u5ea6\u4e3a 0\uff0c\u5bb9\u91cf\u4e3a 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* \u6808\u7684\u957f\u5ea6 */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* \u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* \u5165\u6808 */\nfunc (s *arrayStack) push(v int) {\n    // \u5207\u7247\u4f1a\u81ea\u52a8\u6269\u5bb9\n    s.data = append(s.data, v)\n}\n\n/* \u51fa\u6808 */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* \u83b7\u53d6\u6808\u9876\u5143\u7d20 */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n
    array_stack.swift
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = []\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        stack.count\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        stack.isEmpty\n    }\n\n    /* \u5165\u6808 */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* \u51fa\u6808 */\n    @discardableResult\n    func pop() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return stack.removeLast()\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return stack.last!\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        stack\n    }\n}\n
    array_stack.js
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    pop() {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stack.pop();\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    top() {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n
    array_stack.ts
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stack.pop();\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        return this.stack;\n    }\n}\n
    array_stack.dart
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n  late List<int> _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n  int size() {\n    return _stack.length;\n  }\n\n  /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* \u5165\u6808 */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* \u51fa\u6808 */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stack.last;\n  }\n\n  /* \u5c06\u6808\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n  List<int> toArray() => _stack;\n}\n
    array_stack.rs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nstruct ArrayStack<T> {\n    stack: Vec<T>,\n}\n\nimpl<T> ArrayStack<T> {\n    /* \u521d\u59cb\u5316\u6808 */\n    fn new() -> ArrayStack<T> {\n        ArrayStack::<T> {\n            stack: Vec::<T>::new(),\n        }\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fn size(&self) -> usize {\n        self.stack.len()\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fn is_empty(&self) -> bool {\n        self.size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fn push(&mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    fn pop(&mut self) -> Option<T> {\n        self.stack.pop()\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fn peek(&self) -> Option<&T> {\n        if self.is_empty() {\n            panic!(\"\u6808\u4e3a\u7a7a\")\n        };\n        self.stack.last()\n    }\n\n    /* \u8fd4\u56de &Vec */\n    fn to_array(&self) -> &Vec<T> {\n        &self.stack\n    }\n}\n
    array_stack.c
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5927\u5bb9\u91cf\uff0c\u907f\u514d\u6269\u5bb9\n    stack->data = malloc(sizeof(int) * MAX_SIZE);\n    stack->size = 0;\n    return stack;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack->data);\n    free(stack);\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(ArrayStack *stack) {\n    return stack->size;\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(ArrayStack *stack) {\n    return stack->size == 0;\n}\n\n/* \u5165\u6808 */\nvoid push(ArrayStack *stack, int num) {\n    if (stack->size == MAX_SIZE) {\n        printf(\"\u6808\u5df2\u6ee1\\n\");\n        return;\n    }\n    stack->data[stack->size] = num;\n    stack->size++;\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(ArrayStack *stack) {\n    if (stack->size == 0) {\n        printf(\"\u6808\u4e3a\u7a7a\\n\");\n        return INT_MAX;\n    }\n    return stack->data[stack->size - 1];\n}\n\n/* \u51fa\u6808 */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack->size--;\n    return val;\n}\n
    array_stack.kt
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n    private val stack = ArrayList<Int>()\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* \u51fa\u6808 */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): Array<Any> {\n        return stack.toArray()\n    }\n}\n
    array_stack.rb
    [class]{ArrayStack}-[func]{}\n
    array_stack.zig
    // \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\nfn ArrayStack(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        stack: ?std.ArrayList(T) = null,     \n\n        // \u6784\u9020\u65b9\u6cd5\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) void {\n            if (self.stack == null) {\n                self.stack = std.ArrayList(T).init(allocator);\n            }\n        }\n\n        // \u6790\u6784\u65b9\u6cd5\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.stack == null) return;\n            self.stack.?.deinit();\n        }\n\n        // \u83b7\u53d6\u6808\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.stack.?.items.len;\n        }\n\n        // \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u6808\u9876\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u6808\u4e3a\u7a7a\");\n            return self.stack.?.items[self.size() - 1];\n        }  \n\n        // \u5165\u6808\n        pub fn push(self: *Self, num: T) !void {\n            try self.stack.?.append(num);\n        } \n\n        // \u51fa\u6808\n        pub fn pop(self: *Self) T {\n            var num = self.stack.?.pop();\n            return num;\n        } \n\n        // \u8fd4\u56de ArrayList\n        pub fn toList(self: *Self) std.ArrayList(T) {\n            return self.stack.?;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_stack_and_queue/stack/#513","title":"5.1.3 \u00a0 \u4e24\u79cd\u5b9e\u73b0\u5bf9\u6bd4","text":"

    \u652f\u6301\u64cd\u4f5c

    \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

    \u65f6\u95f4\u6548\u7387

    \u5728\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0\u4e2d\uff0c\u5165\u6808\u548c\u51fa\u6808\u64cd\u4f5c\u90fd\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\u57fa\u4e8e\u94fe\u8868\u7684\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\u65f6\uff0c\u4f8b\u5982 int \u6216 double \uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u4ee5\u4e0b\u7ed3\u8bba\u3002

    • \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\u3002
    • \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\u53ef\u4ee5\u63d0\u4f9b\u66f4\u52a0\u7a33\u5b9a\u7684\u6548\u7387\u8868\u73b0\u3002

    \u7a7a\u95f4\u6548\u7387

    \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\u51fa\u5b9e\u9645\u9700\u6c42\uff1b\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\u7684\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\u7684\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\u5bf9\u4e0a\u4e00\u4e2a\u7f51\u9875\u6267\u884c\u5165\u6808\uff0c\u8fd9\u6837\u6211\u4eec\u5c31\u53ef\u4ee5\u901a\u8fc7\u540e\u9000\u64cd\u4f5c\u56de\u5230\u4e0a\u4e00\u4e2a\u7f51\u9875\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\u4e0d\u65ad\u6267\u884c\u51fa\u6808\u64cd\u4f5c\u3002
    "},{"location":"chapter_stack_and_queue/summary/","title":"5.4 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_stack_and_queue/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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
    • \u5728\u65f6\u95f4\u6548\u7387\u65b9\u9762\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\u52a3\u5316\u81f3 \\(O(n)\\) \u3002\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u6808\u7684\u94fe\u8868\u5b9e\u73b0\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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u5730\u5b9e\u73b0\u4e00\u4e9b\u989d\u5916\u64cd\u4f5c\uff0c\u8fd9\u4e2a\u5728\u201c\u53cc\u5411\u961f\u5217\u201d\u7ae0\u8282\u6709\u63d0\u5230\u3002

    Q\uff1a\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

    Q\uff1a\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\u6216\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

    Q\uff1a\u64a4\u9500\uff08undo\uff09\u548c\u53cd\u64a4\u9500\uff08redo\uff09\u5177\u4f53\u662f\u5982\u4f55\u5b9e\u73b0\u7684\uff1f

    \u4f7f\u7528\u4e24\u4e2a\u6808\uff0c\u6808 A \u7528\u4e8e\u64a4\u9500\uff0c\u6808 B \u7528\u4e8e\u53cd\u64a4\u9500\u3002

    1. \u6bcf\u5f53\u7528\u6237\u6267\u884c\u4e00\u4e2a\u64cd\u4f5c\uff0c\u5c06\u8fd9\u4e2a\u64cd\u4f5c\u538b\u5165\u6808 A \uff0c\u5e76\u6e05\u7a7a\u6808 B \u3002
    2. \u5f53\u7528\u6237\u6267\u884c\u201c\u64a4\u9500\u201d\u65f6\uff0c\u4ece\u6808 A \u4e2d\u5f39\u51fa\u6700\u8fd1\u7684\u64cd\u4f5c\uff0c\u5e76\u5c06\u5176\u538b\u5165\u6808 B \u3002
    3. \u5f53\u7528\u6237\u6267\u884c\u201c\u53cd\u64a4\u9500\u201d\u65f6\uff0c\u4ece\u6808 B \u4e2d\u5f39\u51fa\u6700\u8fd1\u7684\u64cd\u4f5c\uff0c\u5e76\u5c06\u5176\u538b\u5165\u6808 A \u3002
    "},{"location":"chapter_tree/","title":"\u7b2c 7 \u7ae0 \u00a0 \u6811","text":"

    Abstract

    \u53c2\u5929\u5927\u6811\u5145\u6ee1\u751f\u547d\u529b\uff0c\u6839\u6df1\u53f6\u8302\uff0c\u5206\u679d\u6276\u758f\u3002

    \u5b83\u4e3a\u6211\u4eec\u5c55\u73b0\u4e86\u6570\u636e\u5206\u6cbb\u7684\u751f\u52a8\u5f62\u6001\u3002

    "},{"location":"chapter_tree/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 7.1 \u00a0 \u4e8c\u53c9\u6811
    • 7.2 \u00a0 \u4e8c\u53c9\u6811\u904d\u5386
    • 7.3 \u00a0 \u4e8c\u53c9\u6811\u6570\u7ec4\u8868\u793a
    • 7.4 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811
    • 7.5 \u00a0 AVL \u6811 *
    • 7.6 \u00a0 \u5c0f\u7ed3
    "},{"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\u4e0a\u4e00\u8282\u4ecb\u7ecd\u4e86\u94fe\u8868\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7684\u5404\u9879\u57fa\u672c\u64cd\u4f5c\u3002

    \u90a3\u4e48\uff0c\u6211\u4eec\u80fd\u5426\u7528\u6570\u7ec4\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\u3002\u7ed9\u5b9a\u4e00\u68f5\u5b8c\u7f8e\u4e8c\u53c9\u6811\uff0c\u6211\u4eec\u5c06\u6240\u6709\u8282\u70b9\u6309\u7167\u5c42\u5e8f\u904d\u5386\u7684\u987a\u5e8f\u5b58\u50a8\u5728\u4e00\u4e2a\u6570\u7ec4\u4e2d\uff0c\u5219\u6bcf\u4e2a\u8282\u70b9\u90fd\u5bf9\u5e94\u552f\u4e00\u7684\u6570\u7ec4\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\u67d0\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\u56fe 7-12 \u5c55\u793a\u4e86\u5404\u4e2a\u8282\u70b9\u7d22\u5f15\u4e4b\u95f4\u7684\u6620\u5c04\u5173\u7cfb\u3002

    \u56fe 7-12 \u00a0 \u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    \u6620\u5c04\u516c\u5f0f\u7684\u89d2\u8272\u76f8\u5f53\u4e8e\u94fe\u8868\u4e2d\u7684\u5f15\u7528\u3002\u7ed9\u5b9a\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u4e00\u4e2a\u8282\u70b9\uff0c\u6211\u4eec\u90fd\u53ef\u4ee5\u901a\u8fc7\u6620\u5c04\u516c\u5f0f\u6765\u8bbf\u95ee\u5b83\u7684\u5de6\uff08\u53f3\uff09\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":"

    \u5b8c\u7f8e\u4e8c\u53c9\u6811\u662f\u4e00\u4e2a\u7279\u4f8b\uff0c\u5728\u4e8c\u53c9\u6811\u7684\u4e2d\u95f4\u5c42\u901a\u5e38\u5b58\u5728\u8bb8\u591a None \u3002\u7531\u4e8e\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u5e76\u4e0d\u5305\u542b\u8fd9\u4e9b None \uff0c\u56e0\u6b64\u6211\u4eec\u65e0\u6cd5\u4ec5\u51ed\u8be5\u5e8f\u5217\u6765\u63a8\u6d4b None \u7684\u6570\u91cf\u548c\u5206\u5e03\u4f4d\u7f6e\u3002\u8fd9\u610f\u5473\u7740\u5b58\u5728\u591a\u79cd\u4e8c\u53c9\u6811\u7ed3\u6784\u90fd\u7b26\u5408\u8be5\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u3002

    \u5982\u56fe 7-13 \u6240\u793a\uff0c\u7ed9\u5b9a\u4e00\u68f5\u975e\u5b8c\u7f8e\u4e8c\u53c9\u6811\uff0c\u4e0a\u8ff0\u6570\u7ec4\u8868\u793a\u65b9\u6cd5\u5df2\u7ecf\u5931\u6548\u3002

    \u56fe 7-13 \u00a0 \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 None \u3002\u5982\u56fe 7-14 \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\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a\n# \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 int \u6700\u5927\u503c INT_MAX \u6807\u8bb0\u7a7a\u4f4d\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// \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? \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 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// \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
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \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// \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? \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
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 None \u6765\u6807\u8bb0\u7a7a\u4f4d\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(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 null \u6765\u8868\u793a\u7a7a\u4f4d\nval tree = mutableListOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n
    \n
    \n

    \u56fe 7-14 \u00a0 \u4efb\u610f\u7c7b\u578b\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\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\uff0cNone \u53ea\u51fa\u73b0\u5728\u6700\u5e95\u5c42\u4e14\u9760\u53f3\u7684\u4f4d\u7f6e\uff0c\u56e0\u6b64\u6240\u6709 None \u4e00\u5b9a\u51fa\u73b0\u5728\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u7684\u672b\u5c3e\u3002

    \u8fd9\u610f\u5473\u7740\u4f7f\u7528\u6570\u7ec4\u8868\u793a\u5b8c\u5168\u4e8c\u53c9\u6811\u65f6\uff0c\u53ef\u4ee5\u7701\u7565\u5b58\u50a8\u6240\u6709 None \uff0c\u975e\u5e38\u65b9\u4fbf\u3002\u56fe 7-15 \u7ed9\u51fa\u4e86\u4e00\u4e2a\u4f8b\u5b50\u3002

    \u56fe 7-15 \u00a0 \u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    \u4ee5\u4e0b\u4ee3\u7801\u5b9e\u73b0\u4e86\u4e00\u68f5\u57fa\u4e8e\u6570\u7ec4\u8868\u793a\u7684\u4e8c\u53c9\u6811\uff0c\u5305\u62ec\u4ee5\u4e0b\u51e0\u79cd\u64cd\u4f5c\u3002

    • \u7ed9\u5b9a\u67d0\u8282\u70b9\uff0c\u83b7\u53d6\u5b83\u7684\u503c\u3001\u5de6\uff08\u53f3\uff09\u5b50\u8282\u70b9\u3001\u7236\u8282\u70b9\u3002
    • \u83b7\u53d6\u524d\u5e8f\u904d\u5386\u3001\u4e2d\u5e8f\u904d\u5386\u3001\u540e\u5e8f\u904d\u5386\u3001\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_binary_tree.py
    class ArrayBinaryTree:\n    \"\"\"\u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"\u5217\u8868\u5bb9\u91cf\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -> int:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c\"\"\"\n        # \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de None \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 or i >= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -> list[int]:\n        \"\"\"\u5c42\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\n        if self.val(i) is None:\n            return\n        # \u524d\u5e8f\u904d\u5386\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # \u540e\u5e8f\u904d\u5386\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -> list[int]:\n        \"\"\"\u524d\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -> list[int]:\n        \"\"\"\u4e2d\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -> list[int]:\n        \"\"\"\u540e\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n
    array_binary_tree.cpp
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    ArrayBinaryTree(vector<int> arr) {\n        tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    int size() {\n        return tree.size();\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    int val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de INT_MAX \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    vector<int> levelOrder() {\n        vector<int> res;\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    vector<int> preOrder() {\n        vector<int> res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    vector<int> inOrder() {\n        vector<int> res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    vector<int> postOrder() {\n        vector<int> res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector<int> tree;\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    void dfs(int i, string order, vector<int> &res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (val(i) == INT_MAX)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n
    array_binary_tree.java
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    private List<Integer> tree;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayBinaryTree(List<Integer> arr) {\n        tree = new ArrayList<>(arr);\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    public int size() {\n        return tree.size();\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    public Integer val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    public List<Integer> levelOrder() {\n        List<Integer> res = new ArrayList<>();\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    private void dfs(Integer i, String order, List<Integer> res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (val(i) == null)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    public List<Integer> preOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    public List<Integer> inOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    public List<Integer> postOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n
    array_binary_tree.cs
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree(List<int?> arr) {\n    List<int?> tree = new(arr);\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    public int? Val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    public List<int> LevelOrder() {\n        List<int> res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    void DFS(int i, string order, List<int> res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (!Val(i).HasValue)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    public List<int> PreOrder() {\n        List<int> res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    public List<int> InOrder() {\n        List<int> res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    public List<int> PostOrder() {\n        List<int> res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n
    array_binary_tree.go
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* \u5217\u8868\u5bb9\u91cf */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if i < 0 || i >= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* \u5c42\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n    for i := 0; i < abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if abt.val(i) == nil {\n        return\n    }\n    // \u524d\u5e8f\u904d\u5386\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // \u4e2d\u5e8f\u904d\u5386\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // \u540e\u5e8f\u904d\u5386\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* \u524d\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &res)\n    return res\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &res)\n    return res\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &res)\n    return res\n}\n
    array_binary_tree.swift
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    func size() -> Int {\n        tree.count\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    func val(i: Int) -> Int? {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 || i >= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    func left(i: Int) -> Int {\n        2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    func right(i: Int) -> Int {\n        2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    func parent(i: Int) -> Int {\n        (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    func levelOrder() -> [Int] {\n        var res: [Int] = []\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in 0 ..< size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        guard let val = val(i: i) else {\n            return\n        }\n        // \u524d\u5e8f\u904d\u5386\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &res)\n        // \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &res)\n        // \u540e\u5e8f\u904d\u5386\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    func preOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &res)\n        return res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    func inOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &res)\n        return res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    func postOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &res)\n        return res\n    }\n}\n
    array_binary_tree.js
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    val(i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    levelOrder() {\n        let res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (let i = 0; i < this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    #dfs(i, order, res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (this.val(i) === null) return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n
    array_binary_tree.ts
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    val(i: number): number | null {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    levelOrder(): number[] {\n        let res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (let i = 0; i < this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (this.val(i) === null) return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n
    array_binary_tree.dart
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n  late List<int?> _tree;\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  ArrayBinaryTree(this._tree);\n\n  /* \u5217\u8868\u5bb9\u91cf */\n  int size() {\n    return _tree.length;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n  int? val(int i) {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if (i < 0 || i >= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* \u5c42\u5e8f\u904d\u5386 */\n  List<int> levelOrder() {\n    List<int> res = [];\n    for (int i = 0; i < size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n  void dfs(int i, String order, List<int?> res) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if (val(i) == null) {\n      return;\n    }\n    // \u524d\u5e8f\u904d\u5386\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // \u4e2d\u5e8f\u904d\u5386\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // \u540e\u5e8f\u904d\u5386\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* \u524d\u5e8f\u904d\u5386 */\n  List<int?> preOrder() {\n    List<int?> res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* \u4e2d\u5e8f\u904d\u5386 */\n  List<int?> inOrder() {\n    List<int?> res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* \u540e\u5e8f\u904d\u5386 */\n  List<int?> postOrder() {\n    List<int?> res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n
    array_binary_tree.rs
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nstruct ArrayBinaryTree {\n    tree: Vec<Option<i32>>,\n}\n\nimpl ArrayBinaryTree {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(arr: Vec<Option<i32>>) -> Self {\n        Self { tree: arr }\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    fn size(&self) -> i32 {\n        self.tree.len() as i32\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    fn val(&self, i: i32) -> Option<i32> {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de None \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 || i >= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn left(&self, i: i32) -> i32 {\n        2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn right(&self, i: i32) -> i32 {\n        2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn parent(&self, i: i32) -> i32 {\n        (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    fn level_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in 0..self.size() {\n            if let Some(val) = self.val(i) {\n                res.push(val)\n            }\n        }\n        res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    fn dfs(&self, i: i32, order: &str, res: &mut Vec<i32>) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // \u524d\u5e8f\u904d\u5386\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    fn pre_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &mut res);\n        res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    fn in_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &mut res);\n        res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    fn post_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &mut res);\n        res\n    }\n}\n
    array_binary_tree.c
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7ed3\u6784\u4f53 */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt->tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt->tree, arr, sizeof(int) * arrSize);\n    abt->size = arrSize;\n    return abt;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt->tree);\n    free(abt);\n}\n\n/* \u5217\u8868\u5bb9\u91cf */\nint size(ArrayBinaryTree *abt) {\n    return abt->size;\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\nint val(ArrayBinaryTree *abt, int i) {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de INT_MAX \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if (i < 0 || i >= size(abt))\n        return INT_MAX;\n    return abt->tree[i];\n}\n\n/* \u5c42\u5e8f\u904d\u5386 */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if (val(abt, i) == INT_MAX)\n        return;\n    // \u524d\u5e8f\u904d\u5386\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // \u4e2d\u5e8f\u904d\u5386\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // \u540e\u5e8f\u904d\u5386\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* \u524d\u5e8f\u904d\u5386 */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &index);\n    *returnSize = index;\n    return res;\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &index);\n    *returnSize = index;\n    return res;\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &index);\n    *returnSize = index;\n    return res;\n}\n
    array_binary_tree.kt
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree(val tree: List<Int?>) {\n    /* \u5217\u8868\u5bb9\u91cf */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    fun value(i: Int): Int? {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size()) return null\n        return tree[i]\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    fun levelOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (i in 0..<size()) {\n            if (value(i) != null) res.add(value(i))\n        }\n        return res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    fun dfs(i: Int, order: String, res: MutableList<Int?>) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (value(i) == null) return\n        // \u524d\u5e8f\u904d\u5386\n        if (\"pre\" == order) res.add(value(i))\n        dfs(left(i), order, res)\n        // \u4e2d\u5e8f\u904d\u5386\n        if (\"in\" == order) res.add(value(i))\n        dfs(right(i), order, res)\n        // \u540e\u5e8f\u904d\u5386\n        if (\"post\" == order) res.add(value(i))\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    fun preOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    fun inOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    fun postOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n
    array_binary_tree.rb
    [class]{ArrayBinaryTree}-[func]{}\n
    array_binary_tree.zig
    [class]{ArrayBinaryTree}-[func]{}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/array_representation_of_tree/#733","title":"7.3.3 \u00a0 \u4f18\u70b9\u4e0e\u5c40\u9650\u6027","text":"

    \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a\u4e3b\u8981\u6709\u4ee5\u4e0b\u4f18\u70b9\u3002

    • \u6570\u7ec4\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u5bf9\u7f13\u5b58\u53cb\u597d\uff0c\u8bbf\u95ee\u4e0e\u904d\u5386\u901f\u5ea6\u8f83\u5feb\u3002
    • \u4e0d\u9700\u8981\u5b58\u50a8\u6307\u9488\uff0c\u6bd4\u8f83\u8282\u7701\u7a7a\u95f4\u3002
    • \u5141\u8bb8\u968f\u673a\u8bbf\u95ee\u8282\u70b9\u3002

    \u7136\u800c\uff0c\u6570\u7ec4\u8868\u793a\u4e5f\u5b58\u5728\u4e00\u4e9b\u5c40\u9650\u6027\u3002

    • \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\u3002
    • \u5f53\u4e8c\u53c9\u6811\u4e2d\u5b58\u5728\u5927\u91cf 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
    "},{"location":"chapter_tree/avl_tree/","title":"7.5 \u00a0 AVL \u6811 *","text":"

    \u5728\u201c\u4e8c\u53c9\u641c\u7d22\u6811\u201d\u7ae0\u8282\u4e2d\u6211\u4eec\u63d0\u5230\uff0c\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\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6240\u6709\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5c06\u4ece \\(O(\\log n)\\) \u52a3\u5316\u4e3a \\(O(n)\\) \u3002

    \u5982\u56fe 7-24 \u6240\u793a\uff0c\u7ecf\u8fc7\u4e24\u6b21\u5220\u9664\u8282\u70b9\u64cd\u4f5c\uff0c\u8fd9\u68f5\u4e8c\u53c9\u641c\u7d22\u6811\u4fbf\u4f1a\u9000\u5316\u4e3a\u94fe\u8868\u3002

    \u56fe 7-24 \u00a0 AVL \u6811\u5728\u5220\u9664\u8282\u70b9\u540e\u53d1\u751f\u9000\u5316

    \u518d\u4f8b\u5982\uff0c\u5728\u56fe 7-25 \u6240\u793a\u7684\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\u52a3\u5316\u3002

    \u56fe 7-25 \u00a0 AVL \u6811\u5728\u63d2\u5165\u8282\u70b9\u540e\u53d1\u751f\u9000\u5316

    1962 \u5e74 G. M. Adelson-Velsky \u548c E. M. Landis \u5728\u8bba\u6587\u201cAn algorithm for the organization of information\u201d\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":"

    AVL \u6811\u65e2\u662f\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\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\u662f\u4e00\u79cd\u300c\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811 balanced binary search tree\u300d\u3002

    "},{"location":"chapter_tree/avl_tree/#1","title":"1. \u00a0 \u8282\u70b9\u9ad8\u5ea6","text":"

    \u7531\u4e8e AVL \u6811\u7684\u76f8\u5173\u64cd\u4f5c\u9700\u8981\u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6\uff0c\u56e0\u6b64\u6211\u4eec\u9700\u8981\u4e3a\u8282\u70b9\u7c7b\u6dfb\u52a0 height \u53d8\u91cf\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class TreeNode:\n    \"\"\"AVL \u6811\u8282\u70b9\u7c7b\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # \u8282\u70b9\u503c\n        self.height: int = 0                # \u8282\u70b9\u9ad8\u5ea6\n        self.left: TreeNode | None = None   # \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n        self.right: TreeNode | None = None  # \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nstruct TreeNode {\n    int val{};          // \u8282\u70b9\u503c\n    int height = 0;     // \u8282\u70b9\u9ad8\u5ea6\n    TreeNode *left{};   // \u5de6\u5b50\u8282\u70b9\n    TreeNode *right{};  // \u53f3\u5b50\u8282\u70b9\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    public int val;        // \u8282\u70b9\u503c\n    public int height;     // \u8282\u70b9\u9ad8\u5ea6\n    public TreeNode left;  // \u5de6\u5b50\u8282\u70b9\n    public TreeNode right; // \u53f3\u5b50\u8282\u70b9\n    public TreeNode(int x) { val = x; }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode(int? x) {\n    public int? val = x;    // \u8282\u70b9\u503c\n    public int height;      // \u8282\u70b9\u9ad8\u5ea6\n    public TreeNode? left;  // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    public TreeNode? right; // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    /* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype TreeNode struct {\n    Val    int       // \u8282\u70b9\u503c\n    Height int       // \u8282\u70b9\u9ad8\u5ea6\n    Left   *TreeNode // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    Right  *TreeNode // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    var val: Int // \u8282\u70b9\u503c\n    var height: Int // \u8282\u70b9\u9ad8\u5ea6\n    var left: TreeNode? // \u5de6\u5b50\u8282\u70b9\n    var right: TreeNode? // \u53f3\u5b50\u8282\u70b9\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    val; // \u8282\u70b9\u503c\n    height; //\u8282\u70b9\u9ad8\u5ea6\n    left; // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    val: number;            // \u8282\u70b9\u503c\n    height: number;         // \u8282\u70b9\u9ad8\u5ea6\n    left: TreeNode | null;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    right: TreeNode | null; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height; \n        this.left = left === undefined ? null : left; \n        this.right = right === undefined ? null : right; \n    }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n  int val;         // \u8282\u70b9\u503c\n  int height;      // \u8282\u70b9\u9ad8\u5ea6\n  TreeNode? left;  // \u5de6\u5b50\u8282\u70b9\n  TreeNode? right; // \u53f3\u5b50\u8282\u70b9\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\n    val: i32,                               // \u8282\u70b9\u503c\n    height: i32,                            // \u8282\u70b9\u9ad8\u5ea6\n    left: Option<Rc<RefCell<TreeNode>>>,    // \u5de6\u5b50\u8282\u70b9\n    right: Option<Rc<RefCell<TreeNode>>>,   // \u53f3\u5b50\u8282\u70b9\n}\n\nimpl TreeNode {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(val: i32) -> Rc<RefCell<Self>> {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n
    /* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nTreeNode struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node->val = val;\n    node->height = 0;\n    node->left = NULL;\n    node->right = NULL;\n    return node;\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode(val _val: Int) {  // \u8282\u70b9\u503c\n    val height: Int = 0          // \u8282\u70b9\u9ad8\u5ea6\n    val left: TreeNode? = null   // \u5de6\u5b50\u8282\u70b9\n    val right: TreeNode? = null  // \u53f3\u5b50\u8282\u70b9\n}\n
    \n
    \n

    \u201c\u8282\u70b9\u9ad8\u5ea6\u201d\u662f\u6307\u4ece\u8be5\u8282\u70b9\u5230\u5b83\u7684\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if node is not None:\n        return node.height\n    return -1\n\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\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\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\n    return node == nullptr ? -1 : node->height;\n}\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\n    node->height = max(height(node->left), height(node->right)) + 1;\n}\n
    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\n    return node == null ? -1 : node.height;\n}\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\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\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\n    return node == null ? -1 : node.height;\n}\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\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\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\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    if lh > rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\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\n    node?.height ?? -1\n}\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\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\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\n    return node === null ? -1 : node.height;\n}\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\n    node.height =\n        Math.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\n    return node === null ? -1 : node.height;\n}\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\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n
    avl_tree.dart
    /* \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\n  return node == null ? -1 : node.height;\n}\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\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n
    avl_tree.rs
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfn height(node: OptionTreeNodeRc) -> i32 {\n    // \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\n    match node {\n        Some(node) => node.borrow().height,\n        None => -1,\n    }\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\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\n    if (node != NULL) {\n        return node->height;\n    }\n    return -1;\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node->left);\n    int rh = height(node->right);\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    if (lh > rh) {\n        node->height = lh + 1;\n    } else {\n        node->height = rh + 1;\n    }\n}\n
    avl_tree.kt
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfun height(node: TreeNode?): Int {\n    // \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\n    return node?.height ?: -1\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfun updateHeight(node: TreeNode?) {\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    node?.height = (max(height(node?.left).toDouble(), height(node?.right).toDouble()) + 1).toInt()\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{height}\n\n[class]{AVLTree}-[func]{update_height}\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\n    return if (node == null) -1 else node.?.height;\n}\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\n    node.?.height = @max(self.height(node.?.left), self.height(node.?.right)) + 1;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2","title":"2. \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if node is None:\n        return 0\n    # \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return self.height(node.left) - self.height(node.right)\n
    avl_tree.cpp
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode *node) {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == nullptr)\n        return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node->left) - height(node->right);\n}\n
    avl_tree.java
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode node) {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == null)\n        return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return 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\n    if (node == null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return Height(node.left) - Height(node.right);\n}\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\n    if node == nil {\n        return 0\n    }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return t.height(node.Left) - t.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\n    guard let node = node else { return 0 }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node: node.left) - height(node: 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\n    if (node === null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return 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\n    if (node === null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return this.height(node.left) - this.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\n  if (node == null) return 0;\n  // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n  return height(node.left) - height(node.right);\n}\n
    avl_tree.rs
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfn balance_factor(node: OptionTreeNodeRc) -> i32 {\n    match node {\n        // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n        None => 0,\n        // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n        Some(node) => {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\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\n    if (node == NULL) {\n        return 0;\n    }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node->left) - height(node->right);\n}\n
    avl_tree.kt
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfun balanceFactor(node: TreeNode?): Int {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == null) return 0\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node.left) - height(node.right)\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{balance_factor}\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\n    if (node == null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return self.height(node.?.left) - self.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\u201c\u65cb\u8f6c\u201d\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\u201c\u4e8c\u53c9\u641c\u7d22\u6811\u201d\u7684\u6027\u8d28\uff0c\u4e5f\u80fd\u4f7f\u6811\u91cd\u65b0\u53d8\u4e3a\u201c\u5e73\u8861\u4e8c\u53c9\u6811\u201d\u3002

    \u6211\u4eec\u5c06\u5e73\u8861\u56e0\u5b50\u7edd\u5bf9\u503c \\(> 1\\) \u7684\u8282\u70b9\u79f0\u4e3a\u201c\u5931\u8861\u8282\u70b9\u201d\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\u8be6\u7ec6\u4ecb\u7ecd\u8fd9\u4e9b\u65cb\u8f6c\u64cd\u4f5c\u3002

    "},{"location":"chapter_tree/avl_tree/#1_1","title":"1. \u00a0 \u53f3\u65cb","text":"

    \u5982\u56fe 7-26 \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\u201c\u53f3\u65cb\u201d\u64cd\u4f5c\u3002\u5b8c\u6210\u53f3\u65cb\u540e\uff0c\u5b50\u6811\u6062\u590d\u5e73\u8861\uff0c\u5e76\u4e14\u4ecd\u7136\u4fdd\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6027\u8d28\u3002

    <1><2><3><4>

    \u56fe 7-26 \u00a0 \u53f3\u65cb\u64cd\u4f5c\u6b65\u9aa4

    \u5982\u56fe 7-27 \u6240\u793a\uff0c\u5f53\u8282\u70b9 child \u6709\u53f3\u5b50\u8282\u70b9\uff08\u8bb0\u4e3a grand_child \uff09\u65f6\uff0c\u9700\u8981\u5728\u53f3\u65cb\u4e2d\u6dfb\u52a0\u4e00\u6b65\uff1a\u5c06 grand_child \u4f5c\u4e3a node \u7684\u5de6\u5b50\u8282\u70b9\u3002

    \u56fe 7-27 \u00a0 \u6709 grand_child \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def right_rotate(self, node: TreeNode | None) -> TreeNode | None:\n    \"\"\"\u53f3\u65cb\u64cd\u4f5c\"\"\"\n    child = node.left\n    grand_child = child.right\n    # \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node\n    node.left = grand_child\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    self.update_height(child)\n    # \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n
    avl_tree.cpp
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node->left;\n    TreeNode *grandChild = child->right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child->right = node;\n    node->left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.java
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.cs
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.go
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.Right = node\n    node.Left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.swift
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc rightRotate(node: TreeNode?) -> TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child?.right = node\n    node?.left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.js
    /* \u53f3\u65cb\u64cd\u4f5c */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.ts
    /* \u53f3\u65cb\u64cd\u4f5c */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.dart
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n  child.right = node;\n  node.left = grandChild;\n  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n  updateHeight(node);\n  updateHeight(child);\n  // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return child;\n}\n
    avl_tree.rs
    /* \u53f3\u65cb\u64cd\u4f5c */\nfn right_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    match node {\n        Some(node) => {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(child)\n        }\n        None => None,\n    }\n}\n
    avl_tree.c
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node->left;\n    grandChild = child->right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child->right = node;\n    node->left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.kt
    /* \u53f3\u65cb\u64cd\u4f5c */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node\n    node.left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node)\n    updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{right_rotate}\n
    avl_tree.zig
    // \u53f3\u65cb\u64cd\u4f5c\nfn rightRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\n    var child = node.?.left;\n    var grandChild = child.?.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.?.right = node;\n    node.?.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.updateHeight(node);\n    self.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2_1","title":"2. \u00a0 \u5de6\u65cb","text":"

    \u76f8\u5e94\u5730\uff0c\u5982\u679c\u8003\u8651\u4e0a\u8ff0\u5931\u8861\u4e8c\u53c9\u6811\u7684\u201c\u955c\u50cf\u201d\uff0c\u5219\u9700\u8981\u6267\u884c\u56fe 7-28 \u6240\u793a\u7684\u201c\u5de6\u65cb\u201d\u64cd\u4f5c\u3002

    \u56fe 7-28 \u00a0 \u5de6\u65cb\u64cd\u4f5c

    \u540c\u7406\uff0c\u5982\u56fe 7-29 \u6240\u793a\uff0c\u5f53\u8282\u70b9 child \u6709\u5de6\u5b50\u8282\u70b9\uff08\u8bb0\u4e3a grand_child \uff09\u65f6\uff0c\u9700\u8981\u5728\u5de6\u65cb\u4e2d\u6dfb\u52a0\u4e00\u6b65\uff1a\u5c06 grand_child \u4f5c\u4e3a node \u7684\u53f3\u5b50\u8282\u70b9\u3002

    \u56fe 7-29 \u00a0 \u6709 grand_child \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\u53ea\u9700\u5c06\u53f3\u65cb\u7684\u5b9e\u73b0\u4ee3\u7801\u4e2d\u7684\u6240\u6709\u7684 left \u66ff\u6362\u4e3a right \uff0c\u5c06\u6240\u6709\u7684 right \u66ff\u6362\u4e3a left \uff0c\u5373\u53ef\u5f97\u5230\u5de6\u65cb\u7684\u5b9e\u73b0\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def left_rotate(self, node: TreeNode | None) -> TreeNode | None:\n    \"\"\"\u5de6\u65cb\u64cd\u4f5c\"\"\"\n    child = node.right\n    grand_child = child.left\n    # \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node\n    node.right = grand_child\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    self.update_height(child)\n    # \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n
    avl_tree.cpp
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node->right;\n    TreeNode *grandChild = child->left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child->left = node;\n    node->right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.java
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.cs
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.go
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.Left = node\n    node.Right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.swift
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc leftRotate(node: TreeNode?) -> TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child?.left = node\n    node?.right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.js
    /* \u5de6\u65cb\u64cd\u4f5c */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.ts
    /* \u5de6\u65cb\u64cd\u4f5c */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.dart
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n  child.left = node;\n  node.right = grandChild;\n  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n  updateHeight(node);\n  updateHeight(child);\n  // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return child;\n}\n
    avl_tree.rs
    /* \u5de6\u65cb\u64cd\u4f5c */\nfn left_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    match node {\n        Some(node) => {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(child)\n        }\n        None => None,\n    }\n}\n
    avl_tree.c
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node->right;\n    grandChild = child->left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child->left = node;\n    node->right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.kt
    /* \u5de6\u65cb\u64cd\u4f5c */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node\n    node.right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node)\n    updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{left_rotate}\n
    avl_tree.zig
    // \u5de6\u65cb\u64cd\u4f5c\nfn leftRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\n    var child = node.?.right;\n    var grandChild = child.?.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.?.left = node;\n    node.?.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.updateHeight(node);\n    self.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#3","title":"3. \u00a0 \u5148\u5de6\u65cb\u540e\u53f3\u65cb","text":"

    \u5bf9\u4e8e\u56fe 7-30 \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\u5bf9 child \u6267\u884c\u201c\u5de6\u65cb\u201d\uff0c\u518d\u5bf9 node \u6267\u884c\u201c\u53f3\u65cb\u201d\u3002

    \u56fe 7-30 \u00a0 \u5148\u5de6\u65cb\u540e\u53f3\u65cb

    "},{"location":"chapter_tree/avl_tree/#4","title":"4. \u00a0 \u5148\u53f3\u65cb\u540e\u5de6\u65cb","text":"

    \u5982\u56fe 7-31 \u6240\u793a\uff0c\u5bf9\u4e8e\u4e0a\u8ff0\u5931\u8861\u4e8c\u53c9\u6811\u7684\u955c\u50cf\u60c5\u51b5\uff0c\u9700\u8981\u5148\u5bf9 child \u6267\u884c\u201c\u53f3\u65cb\u201d\uff0c\u518d\u5bf9 node \u6267\u884c\u201c\u5de6\u65cb\u201d\u3002

    \u56fe 7-31 \u00a0 \u5148\u53f3\u65cb\u540e\u5de6\u65cb

    "},{"location":"chapter_tree/avl_tree/#5","title":"5. \u00a0 \u65cb\u8f6c\u7684\u9009\u62e9","text":"

    \u56fe 7-32 \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\u5148\u5de6\u65cb\u540e\u53f3\u65cb\u3001\u5148\u53f3\u65cb\u540e\u5de6\u65cb\u3001\u5de6\u65cb\u7684\u64cd\u4f5c\u3002

    \u56fe 7-32 \u00a0 AVL \u6811\u7684\u56db\u79cd\u65cb\u8f6c\u60c5\u51b5

    \u5982\u4e0b\u8868\u6240\u793a\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\u56fe 7-32 \u4e2d\u7684\u54ea\u79cd\u60c5\u51b5\u3002

    \u8868 7-3 \u00a0 \u56db\u79cd\u65cb\u8f6c\u60c5\u51b5\u7684\u9009\u62e9\u6761\u4ef6

    \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\u5de6\u504f\u6811\uff09 \\(\\geq 0\\) \u53f3\u65cb \\(> 1\\) \uff08\u5de6\u504f\u6811\uff09 \\(<0\\) \u5148\u5de6\u65cb\u540e\u53f3\u65cb \\(< -1\\) \uff08\u53f3\u504f\u6811\uff09 \\(\\leq 0\\) \u5de6\u65cb \\(< -1\\) \uff08\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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    balance_factor = self.balance_factor(node)\n    # \u5de6\u504f\u6811\n    if balance_factor > 1:\n        if self.balance_factor(node.left) >= 0:\n            # \u53f3\u65cb\n            return self.right_rotate(node)\n        else:\n            # \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # \u53f3\u504f\u6811\n    elif balance_factor < -1:\n        if self.balance_factor(node.right) <= 0:\n            # \u5de6\u65cb\n            return self.left_rotate(node)\n        else:\n            # \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node\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\n    int _balanceFactor = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (_balanceFactor > 1) {\n        if (balanceFactor(node->left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node->left = leftRotate(node->left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (_balanceFactor < -1) {\n        if (balanceFactor(node->right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node->right = rightRotate(node->right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\n
    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\n    int balanceFactor = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    int balanceFactorInt = BalanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactorInt > 1) {\n        if (BalanceFactor(node?.left) >= 0) {\n            // \u53f3\u65cb\n            return RightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactorInt < -1) {\n        if (BalanceFactor(node?.right) <= 0) {\n            // \u5de6\u65cb\n            return LeftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\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\n    bf := t.balanceFactor(node)\n    // \u5de6\u504f\u6811\n    if bf > 1 {\n        if t.balanceFactor(node.Left) >= 0 {\n            // \u53f3\u65cb\n            return t.rightRotate(node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if bf < -1 {\n        if t.balanceFactor(node.Right) <= 0 {\n            // \u5de6\u65cb\n            return t.leftRotate(node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    let balanceFactor = balanceFactor(node: node)\n    // \u5de6\u504f\u6811\n    if balanceFactor > 1 {\n        if self.balanceFactor(node: node?.left) >= 0 {\n            // \u53f3\u65cb\n            return rightRotate(node: node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if balanceFactor < -1 {\n        if self.balanceFactor(node: node?.right) <= 0 {\n            // \u5de6\u65cb\n            return leftRotate(node: node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    const balanceFactor = this.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (this.balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return this.#rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (this.balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return this.#leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    const balanceFactor = this.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (this.balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return this.rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (this.balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return this.leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n  int factor = balanceFactor(node);\n  // \u5de6\u504f\u6811\n  if (factor > 1) {\n    if (balanceFactor(node!.left) >= 0) {\n      // \u53f3\u65cb\n      return rightRotate(node);\n    } else {\n      // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // \u53f3\u504f\u6811\n  if (factor < -1) {\n    if (balanceFactor(node!.right) <= 0) {\n      // \u5de6\u65cb\n      return leftRotate(node);\n    } else {\n      // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n  return node;\n}\n
    avl_tree.rs
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfn rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    // \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\n    let balance_factor = Self::balance_factor(node.clone());\n    // \u5de6\u504f\u6811\n    if balance_factor > 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) >= 0 {\n            // \u53f3\u65cb\n            Self::right_rotate(Some(node))\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // \u53f3\u504f\u6811\n    else if balance_factor < -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) <= 0 {\n            // \u5de6\u65cb\n            Self::left_rotate(Some(node))\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n        node\n    }\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\n    int bf = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (bf > 1) {\n        if (balanceFactor(node->left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node->left = leftRotate(node->left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (bf < -1) {\n        if (balanceFactor(node->right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node->right = rightRotate(node->right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\n
    avl_tree.kt
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfun rotate(node: TreeNode): TreeNode {\n    // \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\n    val balanceFactor = balanceFactor(node)\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{rotate}\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\n    var balance_factor = self.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balance_factor > 1) {\n        if (self.balanceFactor(node.?.left) >= 0) {\n            // \u53f3\u65cb\n            return self.rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.?.left = self.leftRotate(node.?.left);\n            return self.rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balance_factor < -1) {\n        if (self.balanceFactor(node.?.right) <= 0) {\n            // \u5de6\u65cb\n            return self.leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.?.right = self.rightRotate(node.?.right);\n            return self.leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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/#1_2","title":"1. \u00a0 \u63d2\u5165\u8282\u70b9","text":"

    AVL \u6811\u7684\u8282\u70b9\u63d2\u5165\u64cd\u4f5c\u4e0e\u4e8c\u53c9\u641c\u7d22\u6811\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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def insert(self, val):\n    \"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:\n    \"\"\"\u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9\n    if val < node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val > node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    # 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\n    return self.rotate(node)\n
    avl_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node->val)\n        node->left = insertHelper(node->left, val);\n    else if (val > node->val)\n        node->right = insertHelper(node->right, val);\n    else\n        return node;    // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = Rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if val < node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val > node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = t.rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc insertHelper(node: TreeNode?, val: Int) -> TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if val < node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val > node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    updateHeight(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 */\n    node = rotate(node: node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    this.#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 */\n    node = this.#rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val > node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    this.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 */\n    node = this.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.dart
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n  if (val < node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val > node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n  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 */\n  node = rotate(node);\n  // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return node;\n}\n
    avl_tree.rs
    /* \u63d2\u5165\u8282\u70b9 */\nfn insert(&mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {\n    match node {\n        Some(mut node) => {\n            /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&val)\n            {\n                Ordering::Greater => {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less => {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal => {\n                    return Some(node); // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n                }\n            }\n            Self::update_height(Some(node.clone())); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n\n            /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n            node = Self::rotate(Some(node)).unwrap();\n            // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(node)\n        }\n        None => Some(TreeNode::new(val)),\n    }\n}\n
    avl_tree.c
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(AVLTree *tree, int val) {\n    tree->root = insertHelper(tree->root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node->val) {\n        node->left = insertHelper(node->left, val);\n    } else if (val > node->val) {\n        node->right = insertHelper(node->right, val);\n    } else {\n        // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node;\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.kt
    /* \u63d2\u5165\u8282\u70b9 */\nfun insert(value: Int) {\n    root = insertHelper(root, value)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfun insertHelper(n: TreeNode?, value: Int): TreeNode {\n    if (n == null)\n        return TreeNode(value)\n    var node = n\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (value < node.value) node.left = insertHelper(node.left, value)\n    else if (value > node.value) node.right = insertHelper(node.right, value)\n    else return node // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n\n    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 */\n    node = rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{insert}\n\n[class]{AVLTree}-[func]{insert_helper}\n
    avl_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, val: T) !void {\n    self.root = (try self.insertHelper(self.root, val)).?;\n}\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) {\n    var node = node_;\n    if (node == null) {\n        var tmp_node = try self.mem_allocator.create(inc.TreeNode(T));\n        tmp_node.init(val);\n        return tmp_node;\n    }\n    // 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9\n    if (val < node.?.val) {\n        node.?.left = try self.insertHelper(node.?.left, val);\n    } else if (val > node.?.val) {\n        node.?.right = try self.insertHelper(node.?.right, val);\n    } else {\n        return node;            // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    self.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\n    node = self.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2_2","title":"2. \u00a0 \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\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u6240\u6709\u5931\u8861\u8282\u70b9\u6062\u590d\u5e73\u8861\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def remove(self, val: int):\n    \"\"\"\u5220\u9664\u8282\u70b9\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:\n    \"\"\"\u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\n    if node is None:\n        return None\n    # 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664\n    if val < node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val > node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if child is None:\n                return None\n            # \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else:\n                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\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    # 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\n    return self.rotate(node)\n
    avl_tree.cpp
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node->val)\n        node->left = removeHelper(node->left, val);\n    else if (val > node->val)\n        node->right = removeHelper(node->right, val);\n    else {\n        if (node->left == nullptr || node->right == nullptr) {\n            TreeNode *child = node->left != nullptr ? node->left : node->right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else {\n                delete node;\n                node = 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\n            TreeNode *temp = node->right;\n            while (temp->left != nullptr) {\n                temp = temp->left;\n            }\n            int tempVal = temp->val;\n            node->right = removeHelper(node->right, temp->val);\n            node->val = tempVal;\n        }\n    }\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val > node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == null)\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else\n                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\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.cs
    /* \u5220\u9664\u8282\u70b9 */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val > node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == null)\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else\n                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\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    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 */\n    node = Rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if val < node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val > node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n                return nil\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = t.rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc removeHelper(node: TreeNode?, val: Int) -> TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if val < node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val > node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if child == nil {\n                return nil\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else {\n                node = 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\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(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 */\n    node = rotate(node: node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val > node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child === null) return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else 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\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#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 */\n    node = this.#rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val > node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child === null) {\n                return null;\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.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 */\n    node = this.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.dart
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n  if (val < node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val > node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n      if (child == null)\n        return null;\n      // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n      else\n        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\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  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 */\n  node = rotate(node);\n  // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return node;\n}\n
    avl_tree.rs
    /* \u5220\u9664\u8282\u70b9 */\nfn remove(&self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {\n    match node {\n        Some(mut node) => {\n            /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n            if val < node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val > node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n                    None => {\n                        return None;\n                    }\n                    // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                    Some(child) => node = 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\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n\n            /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n            node = Self::rotate(Some(node)).unwrap();\n            // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(node)\n        }\n        None => None,\n    }\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 removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree->root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node->val) {\n        node->left = removeHelper(node->left, val);\n    } else if (val > node->val) {\n        node->right = removeHelper(node->right, val);\n    } else {\n        if (node->left == NULL || node->right == NULL) {\n            child = node->left;\n            if (node->right != NULL) {\n                child = node->right;\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            TreeNode *temp = node->right;\n            while (temp->left != NULL) {\n                temp = temp->left;\n            }\n            int tempVal = temp->val;\n            node->right = removeHelper(node->right, temp->val);\n            node->val = tempVal;\n        }\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.kt
    /* \u5220\u9664\u8282\u70b9 */\nfun remove(value: Int) {\n    root = removeHelper(root, value)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfun removeHelper(n: TreeNode?, value: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (value < node.value) node.left = removeHelper(node.left, value)\n    else if (value > node.value) node.right = removeHelper(node.right, value)\n    else {\n        if (node.left == null || node.right == null) {\n            val 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\n            if (child == null) return null\n            else 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\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp.value)\n            node.value = temp.value\n        }\n    }\n    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 */\n    node = rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{remove}\n\n[class]{AVLTree}-[func]{remove_helper}\n
    avl_tree.zig
    // \u5220\u9664\u8282\u70b9\nfn remove(self: *Self, val: T) void {\n   self.root = self.removeHelper(self.root, val).?;\n}\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) {\n    var node = node_;\n    if (node == null) return null;\n    // 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664\n    if (val < node.?.val) {\n        node.?.left = self.removeHelper(node.?.left, val);\n    } else if (val > node.?.val) {\n        node.?.right = self.removeHelper(node.?.right, val);\n    } else {\n        if (node.?.left == null or node.?.right == null) {\n            var 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\n            if (child == null) {\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            } else {\n                node = 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\n            var temp = node.?.right;\n            while (temp.?.left != null) {\n                temp = temp.?.left;\n            }\n            node.?.right = self.removeHelper(node.?.right, temp.?.val);\n            node.?.val = temp.?.val;\n        }\n    }\n    self.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\n    node = self.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#3_1","title":"3. \u00a0 \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\u3002
    • \u7528\u4e8e\u6784\u5efa\u6570\u636e\u5e93\u4e2d\u7684\u7d22\u5f15\u7cfb\u7edf\u3002
    • \u7ea2\u9ed1\u6811\u4e5f\u662f\u4e00\u79cd\u5e38\u89c1\u7684\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\u3002\u76f8\u8f83\u4e8e AVL \u6811\uff0c\u7ea2\u9ed1\u6811\u7684\u5e73\u8861\u6761\u4ef6\u66f4\u5bbd\u677e\uff0c\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u6240\u9700\u7684\u65cb\u8f6c\u64cd\u4f5c\u66f4\u5c11\uff0c\u8282\u70b9\u589e\u5220\u64cd\u4f5c\u7684\u5e73\u5747\u6548\u7387\u66f4\u9ad8\u3002
    "},{"location":"chapter_tree/binary_search_tree/","title":"7.4 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811","text":"

    \u5982\u56fe 7-16 \u6240\u793a\uff0c\u300c\u4e8c\u53c9\u641c\u7d22\u6811 binary search tree\u300d\u6ee1\u8db3\u4ee5\u4e0b\u6761\u4ef6\u3002

    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\u3002
    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. \u3002

    \u56fe 7-16 \u00a0 \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":"

    \u6211\u4eec\u5c06\u4e8c\u53c9\u641c\u7d22\u6811\u5c01\u88c5\u4e3a\u4e00\u4e2a\u7c7b BinarySearchTree \uff0c\u5e76\u58f0\u660e\u4e00\u4e2a\u6210\u5458\u53d8\u91cf root \uff0c\u6307\u5411\u6811\u7684\u6839\u8282\u70b9\u3002

    "},{"location":"chapter_tree/binary_search_tree/#1","title":"1. \u00a0 \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\u5982\u56fe 7-17 \u6240\u793a\uff0c\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\u3002

    • \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 \u3002
    • \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 \u3002
    • \u82e5 cur.val = num \uff0c\u8bf4\u660e\u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\u5e76\u8fd4\u56de\u8be5\u8282\u70b9\u3002
    <1><2><3><4>

    \u56fe 7-17 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u67e5\u627e\u8282\u70b9\u793a\u4f8b

    \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\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def search(self, num: int) -> TreeNode | None:\n    \"\"\"\u67e5\u627e\u8282\u70b9\"\"\"\n    cur = self._root\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur is not None:\n        # \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        elif cur.val > num:\n            cur = cur.left\n        # \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else:\n            break\n    return cur\n
    binary_search_tree.cpp
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur->val > num)\n            cur = cur->left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.java
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num)\n            cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.cs
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur =\n            cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num)\n            cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.go
    /* \u67e5\u627e\u8282\u70b9 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for node != nil {\n        if node.Val.(int) < num {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            node = node.Right\n        } else if node.Val.(int) > num {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            node = node.Left\n        } else {\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return node\n}\n
    binary_search_tree.swift
    /* \u67e5\u627e\u8282\u70b9 */\nfunc search(num: Int) -> TreeNode? {\n    var cur = root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if cur!.val > num {\n            cur = cur?.left\n        }\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else {\n            break\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur\n}\n
    binary_search_tree.js
    /* \u67e5\u627e\u8282\u70b9 */\nsearch(num) {\n    let cur = this.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num) cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.ts
    /* \u67e5\u627e\u8282\u70b9 */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num) cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.dart
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else if (cur.val > _num)\n      cur = cur.left;\n    // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n    else\n      break;\n  }\n  // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n  return cur;\n}\n
    binary_search_tree.rs
    /* \u67e5\u627e\u8282\u70b9 */\npub fn search(&self, num: i32) -> OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => cur = node.borrow().right.clone(),\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => cur = node.borrow().left.clone(),\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            Ordering::Equal => break,\n        }\n    }\n\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    cur\n}\n
    binary_search_tree.c
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst->root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        if (cur->val < num) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else if (cur->val > num) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.kt
    /* \u67e5\u627e\u8282\u70b9 */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.value > num) cur.left\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{search}\n
    binary_search_tree.zig
    // \u67e5\u627e\u8282\u70b9\nfn search(self: *Self, num: T) ?*inc.TreeNode(T) {\n    var cur = self.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else if (cur.?.val > num) {\n            cur = cur.?.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        } else {\n            break;\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/binary_search_tree/#2","title":"2. \u00a0 \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\u6d41\u7a0b\u5982\u56fe 7-18 \u6240\u793a\u3002

    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 None \uff09\u65f6\u8df3\u51fa\u5faa\u73af\u3002
    2. \u5728\u8be5\u4f4d\u7f6e\u63d2\u5165\u8282\u70b9\uff1a\u521d\u59cb\u5316\u8282\u70b9 num \uff0c\u5c06\u8be5\u8282\u70b9\u7f6e\u4e8e None \u7684\u4f4d\u7f6e\u3002

    \u56fe 7-18 \u00a0 \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u63d2\u5165\u8282\u70b9

    \u5728\u4ee3\u7801\u5b9e\u73b0\u4e2d\uff0c\u9700\u8981\u6ce8\u610f\u4ee5\u4e0b\u4e24\u70b9\u3002

    • \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
    • \u4e3a\u4e86\u5b9e\u73b0\u63d2\u5165\u8282\u70b9\uff0c\u6211\u4eec\u9700\u8981\u501f\u52a9\u8282\u70b9 pre \u4fdd\u5b58\u4e0a\u4e00\u8f6e\u5faa\u73af\u7684\u8282\u70b9\u3002\u8fd9\u6837\u5728\u904d\u5386\u81f3 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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def insert(self, num: int):\n    \"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\n    # \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    cur, pre = self._root, None\n    while cur is not None:\n        # \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if cur.val == num:\n            return\n        pre = cur\n        # \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else:\n            cur = cur.left\n    # \u63d2\u5165\u8282\u70b9\n    node = TreeNode(num)\n    if pre.val < num:\n        pre.right = node\n    else:\n        pre.left = node\n
    binary_search_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur->val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur->left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode *node = new TreeNode(num);\n    if (pre->val < num)\n        pre->right = node;\n    else\n        pre->left = node;\n}\n
    binary_search_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode node = new TreeNode(num);\n    if (pre.val < num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n
    binary_search_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid Insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val < num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n
    binary_search_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // \u5f85\u63d2\u5165\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\n    var pre *TreeNode = nil\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) < num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    node := NewTreeNode(num)\n    if pre.Val.(int) < num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n
    binary_search_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\nfunc insert(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else {\n            cur = cur?.left\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    let node = TreeNode(x: num)\n    if pre!.val < num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n
    binary_search_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val === num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    const node = new TreeNode(num);\n    if (pre.val < num) pre.right = node;\n    else pre.left = node;\n}\n
    binary_search_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(num: number): void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val === num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    const node = new TreeNode(num);\n    if (pre!.val < num) pre!.right = node;\n    else pre!.left = node;\n}\n
    binary_search_tree.dart
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int _num) {\n  // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n    if (cur.val == _num) return;\n    pre = cur;\n    // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else\n      cur = cur.left;\n  }\n  // \u63d2\u5165\u8282\u70b9\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val < _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n
    binary_search_tree.rs
    /* \u63d2\u5165\u8282\u70b9 */\npub fn insert(&mut self, num: i32) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n            Ordering::Equal => return,\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num > pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().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\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (bst->root == NULL) {\n        bst->root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst->root, *pre = NULL;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur->val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur->val < num) {\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else {\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode *node = newTreeNode(num);\n    if (pre->val < num) {\n        pre->right = node;\n    } else {\n        pre->left = node;\n    }\n}\n
    binary_search_tree.kt
    /* \u63d2\u5165\u8282\u70b9 */\nfun insert(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.value == num) return\n        pre = cur\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur.left\n    }\n    // \u63d2\u5165\u8282\u70b9\n    val node = TreeNode(num)\n    if (pre?.value!! < num) pre.right = node\n    else pre.left = node\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{insert}\n
    binary_search_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, num: T) !void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (self.root == null) {\n        self.root = try self.mem_allocator.create(inc.TreeNode(T));\n        return;\n    }\n    var cur = self.root;\n    var pre: ?*inc.TreeNode(T) = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.?.val == num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else {\n            cur = cur.?.left;\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    var node = try self.mem_allocator.create(inc.TreeNode(T));\n    node.init(num);\n    if (pre.?.val < num) {\n        pre.?.right = node;\n    } else {\n        pre.?.left = node;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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":"3. \u00a0 \u5220\u9664\u8282\u70b9","text":"

    \u5148\u5728\u4e8c\u53c9\u6811\u4e2d\u67e5\u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u518d\u5c06\u5176\u5220\u9664\u3002\u4e0e\u63d2\u5165\u8282\u70b9\u7c7b\u4f3c\uff0c\u6211\u4eec\u9700\u8981\u4fdd\u8bc1\u5728\u5220\u9664\u64cd\u4f5c\u5b8c\u6210\u540e\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u201c\u5de6\u5b50\u6811 < \u6839\u8282\u70b9 < \u53f3\u5b50\u6811\u201d\u7684\u6027\u8d28\u4ecd\u7136\u6ee1\u8db3\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u6839\u636e\u76ee\u6807\u8282\u70b9\u7684\u5b50\u8282\u70b9\u6570\u91cf\uff0c\u5206 0\u30011 \u548c 2 \u4e09\u79cd\u60c5\u51b5\uff0c\u6267\u884c\u5bf9\u5e94\u7684\u5220\u9664\u8282\u70b9\u64cd\u4f5c\u3002

    \u5982\u56fe 7-19 \u6240\u793a\uff0c\u5f53\u5f85\u5220\u9664\u8282\u70b9\u7684\u5ea6\u4e3a \\(0\\) \u65f6\uff0c\u8868\u793a\u8be5\u8282\u70b9\u662f\u53f6\u8282\u70b9\uff0c\u53ef\u4ee5\u76f4\u63a5\u5220\u9664\u3002

    \u56fe 7-19 \u00a0 \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u5220\u9664\u8282\u70b9\uff08\u5ea6\u4e3a 0 \uff09

    \u5982\u56fe 7-20 \u6240\u793a\uff0c\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

    \u56fe 7-20 \u00a0 \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\u5b50\u6811 \\(<\\) \u6839\u8282\u70b9 \\(<\\) \u53f3\u5b50\u6811\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\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\uff09\uff0c\u5219\u5220\u9664\u64cd\u4f5c\u6d41\u7a0b\u5982\u56fe 7-21 \u6240\u793a\u3002

    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 \u3002
    2. \u7528 tmp \u7684\u503c\u8986\u76d6\u5f85\u5220\u9664\u8282\u70b9\u7684\u503c\uff0c\u5e76\u5728\u6811\u4e2d\u9012\u5f52\u5220\u9664\u8282\u70b9 tmp \u3002
    <1><2><3><4>

    \u56fe 7-21 \u00a0 \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u5220\u9664\u8282\u70b9\uff08\u5ea6\u4e3a 2 \uff09

    \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\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def remove(self, num: int):\n    \"\"\"\u5220\u9664\u8282\u70b9\"\"\"\n    # \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if self._root is None:\n        return\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    cur, pre = self._root, None\n    while cur is not None:\n        # \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if cur.val == num:\n            break\n        pre = cur\n        # \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else:\n            cur = cur.left\n    # \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur is None:\n        return\n\n    # \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if 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\n        child = cur.left or cur.right\n        # \u5220\u9664\u8282\u70b9 cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            self._root = child\n    # \u5b50\u8282\u70b9\u6570\u91cf = 2\n    else:\n        # \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        self.remove(tmp.val)\n        # \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val\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\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur->val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur->left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == nullptr)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur->left == nullptr || cur->right == nullptr) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\n        TreeNode *child = cur->left != nullptr ? cur->left : cur->right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre->left == cur)\n                pre->left = child;\n            else\n                pre->right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\n        // \u91ca\u653e\u5185\u5b58\n        delete cur;\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\n        TreeNode *tmp = cur->right;\n        while (tmp->left != nullptr) {\n            tmp = tmp->left;\n        }\n        int tmpVal = tmp->val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp->val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur->val = tmpVal;\n    }\n}\n
    binary_search_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\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\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\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\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        TreeNode? child = cur.left ?? cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\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\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        Remove(tmp.val!.Value);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\n    }\n}\n
    binary_search_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5f85\u5220\u9664\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\n    var pre *TreeNode = nil\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) < num {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728\u53f3\u5b50\u6811\u4e2d\n            cur = cur.Right\n        } else {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728\u5de6\u5b50\u6811\u4e2d\n            cur = cur.Left\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5b50\u8282\u70b9\u6570\u4e3a 0 \u6216 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // \u53d6\u51fa\u5f85\u5220\u9664\u8282\u70b9\u7684\u5b50\u8282\u70b9\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // \u5220\u9664\u8282\u70b9 cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            bst.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\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        bst.remove(tmp.Val.(int))\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.Val = tmp.Val\n    }\n}\n
    binary_search_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\nfunc remove(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else {\n            cur = cur?.left\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        let child = cur?.left ?? cur?.right\n        // \u5220\u9664\u8282\u70b9 cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child\n        }\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\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(num: tmp!.val)\n        // \u7528 tmp \u8986\u76d6 cur\n        cur?.val = tmp!.val\n    }\n}\n
    binary_search_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nremove(num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val === num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur === null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        const child = cur.left !== null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            this.root = child;\n        }\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\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        this.remove(tmp.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\n    }\n}\n
    binary_search_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nremove(num: number): void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val === num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur === null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            this.root = child;\n        }\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\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        this.remove(tmp!.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp!.val;\n    }\n}\n
    binary_search_tree.dart
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int _num) {\n  // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n    if (cur.val == _num) break;\n    pre = cur;\n    // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else\n      cur = cur.left;\n  }\n  // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n  if (cur == null) return;\n  // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n    TreeNode? child = cur.left ?? cur.right;\n    // \u5220\u9664\u8282\u70b9 cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n      _root = 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\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n    remove(tmp.val);\n    // \u7528 tmp \u8986\u76d6 cur\n    cur.val = tmp.val;\n  }\n}\n
    binary_search_tree.rs
    /* \u5220\u9664\u8282\u70b9 */\npub fn remove(&mut self, num: i32) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            Ordering::Equal => break,\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) => {\n            // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // \u5220\u9664\u8282\u70b9 cur\n            if !Rc::ptr_eq(&cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() && Rc::ptr_eq(&left.as_ref().unwrap(), &cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n                self.root = child;\n            }\n        }\n        // \u5b50\u8282\u70b9\u6570\u91cf = 2\n        (Some(_), Some(_)) => {\n            // \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmpval = tmp.unwrap().borrow().val;\n            // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n            self.remove(tmpval);\n            // \u7528 tmp \u8986\u76d6 cur\n            cur.borrow_mut().val = tmpval;\n        }\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 removeItem(BinarySearchTree *bst, int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (bst->root == NULL)\n        return;\n    TreeNode *cur = bst->root, *pre = NULL;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur->val == num)\n            break;\n        pre = cur;\n        if (cur->val < num) {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == NULL)\n        return;\n    // \u5224\u65ad\u5f85\u5220\u9664\u8282\u70b9\u662f\u5426\u5b58\u5728\u5b50\u8282\u70b9\n    if (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\n        TreeNode *child = cur->left != NULL ? cur->left : cur->right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (pre->left == cur) {\n            pre->left = child;\n        } else {\n            pre->right = child;\n        }\n        // \u91ca\u653e\u5185\u5b58\n        free(cur);\n    } else {\n        /* \u5b50\u8282\u70b9\u6570\u91cf = 2 */\n        // \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n        TreeNode *tmp = cur->right;\n        while (tmp->left != NULL) {\n            tmp = tmp->left;\n        }\n        int tmpVal = tmp->val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        removeItem(bst, tmp->val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur->val = tmpVal;\n    }\n}\n
    binary_search_tree.kt
    /* \u5220\u9664\u8282\u70b9 */\nfun remove(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (root == null) return\n    var cur = root\n    var pre: TreeNode? = null\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.value == num) break\n        pre = cur\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur.left\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null) return\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        val child = if (cur.left != null) cur.left else cur.right\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre!!.left == cur) pre.left = child\n            else pre.right = child\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = 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\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp.value)\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.value = tmp.value\n    }\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{remove}\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\n    if (self.root == null) return;\n    var cur = self.root;\n    var pre: ?*inc.TreeNode(T) = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.?.val == num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else {\n            cur = cur.?.left;\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.?.left == null or cur.?.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        var child = if (cur.?.left != null) cur.?.left else cur.?.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (pre.?.left == cur) {\n            pre.?.left = child;\n        } else {\n            pre.?.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\n        var tmp = cur.?.right;\n        while (tmp.?.left != null) {\n            tmp = tmp.?.left;\n        }\n        var tmp_val = tmp.?.val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        self.remove(tmp.?.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.?.val = tmp_val;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/binary_search_tree/#4","title":"4. \u00a0 \u4e2d\u5e8f\u904d\u5386\u6709\u5e8f","text":"

    \u5982\u56fe 7-22 \u6240\u793a\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

    \u8fd9\u610f\u5473\u7740\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\u987b\u8fdb\u884c\u989d\u5916\u7684\u6392\u5e8f\u64cd\u4f5c\uff0c\u975e\u5e38\u9ad8\u6548\u3002

    \u56fe 7-22 \u00a0 \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\u8868 7-2 \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\u3002\u53ea\u6709\u5728\u9ad8\u9891\u6dfb\u52a0\u3001\u4f4e\u9891\u67e5\u627e\u5220\u9664\u6570\u636e\u7684\u573a\u666f\u4e0b\uff0c\u6570\u7ec4\u6bd4\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6548\u7387\u66f4\u9ad8\u3002

    \u8868 7-2 \u00a0 \u6570\u7ec4\u4e0e\u641c\u7d22\u6811\u7684\u6548\u7387\u5bf9\u6bd4

    \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\u56fe 7-23 \u6240\u793a\u7684\u94fe\u8868\uff0c\u8fd9\u65f6\u5404\u79cd\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u4f1a\u9000\u5316\u4e3a \\(O(n)\\) \u3002

    \u56fe 7-23 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\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\u201c\u7956\u5148\u201d\u4e0e\u201c\u540e\u4ee3\u201d\u4e4b\u95f4\u7684\u6d3e\u751f\u5173\u7cfb\uff0c\u4f53\u73b0\u4e86\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\u503c\u3001\u5de6\u5b50\u8282\u70b9\u5f15\u7528\u548c\u53f3\u5b50\u8282\u70b9\u5f15\u7528\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class TreeNode:\n    \"\"\"\u4e8c\u53c9\u6811\u8282\u70b9\u7c7b\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # \u8282\u70b9\u503c\n        self.left: TreeNode | None = None  # \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n        self.right: TreeNode | None = None # \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\n    int val;          // \u8282\u70b9\u503c\n    TreeNode *left;   // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    TreeNode *right;  // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    int val;         // \u8282\u70b9\u503c\n    TreeNode left;   // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    TreeNode right;  // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n    TreeNode(int x) { val = x; }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode(int? x) {\n    public int? val = x;    // \u8282\u70b9\u503c\n    public TreeNode? left;  // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    public TreeNode? right; // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc NewTreeNode(v int) *TreeNode {\n    return &TreeNode{\n        Left:  nil, // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n        Right: nil, // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n        Val:   v,   // \u8282\u70b9\u503c\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    var val: Int // \u8282\u70b9\u503c\n    var left: TreeNode? // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    var right: TreeNode? // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n\n    init(x: Int) {\n        val = x\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    val; // \u8282\u70b9\u503c\n    left; // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\n        this.left = left === undefined ? null : left; // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n        this.right = right === undefined ? null : right; // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n  int val;         // \u8282\u70b9\u503c\n  TreeNode? left;  // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n  TreeNode? right; // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n  TreeNode(this.val, [this.left, this.right]);\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\n    val: i32,                               // \u8282\u70b9\u503c\n    left: Option<Rc<RefCell<TreeNode>>>,    // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    right: Option<Rc<RefCell<TreeNode>>>,   // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n\nimpl TreeNode {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(val: i32) -> Rc<RefCell<Self>> {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct TreeNode {\n    int val;                // \u8282\u70b9\u503c\n    int height;             // \u8282\u70b9\u9ad8\u5ea6\n    struct TreeNode *left;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    struct TreeNode *right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n} TreeNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node->val = val;\n    node->height = 0;\n    node->left = NULL;\n    node->right = NULL;\n    return node;\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode(val _val: Int) {  // \u8282\u70b9\u503c\n    val left: TreeNode? = null   // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    val right: TreeNode? = null  // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    \n
    \n

    \u6bcf\u4e2a\u8282\u70b9\u90fd\u6709\u4e24\u4e2a\u5f15\u7528\uff08\u6307\u9488\uff09\uff0c\u5206\u522b\u6307\u5411\u300c\u5de6\u5b50\u8282\u70b9 left-child node\u300d\u548c\u300c\u53f3\u5b50\u8282\u70b9 right-child node\u300d\uff0c\u8be5\u8282\u70b9\u88ab\u79f0\u4e3a\u8fd9\u4e24\u4e2a\u5b50\u8282\u70b9\u7684\u300c\u7236\u8282\u70b9 parent node\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 left subtree\u300d\uff0c\u540c\u7406\u53ef\u5f97\u300c\u53f3\u5b50\u6811 right subtree\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\u5982\u56fe 7-1 \u6240\u793a\uff0c\u5982\u679c\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

    \u56fe 7-1 \u00a0 \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\u7684\u5e38\u7528\u672f\u8bed\u5982\u56fe 7-2 \u6240\u793a\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\u3002
    • \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 None \u3002
    • \u300c\u8fb9 edge\u300d\uff1a\u8fde\u63a5\u4e24\u4e2a\u8282\u70b9\u7684\u7ebf\u6bb5\uff0c\u5373\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\u3002
    • \u8282\u70b9\u6240\u5728\u7684\u300c\u5c42 level\u300d\uff1a\u4ece\u9876\u81f3\u5e95\u9012\u589e\uff0c\u6839\u8282\u70b9\u6240\u5728\u5c42\u4e3a 1 \u3002
    • \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\u53d6\u503c\u8303\u56f4\u662f 0\u30011\u30012 \u3002
    • \u4e8c\u53c9\u6811\u7684\u300c\u9ad8\u5ea6 height\u300d\uff1a\u4ece\u6839\u8282\u70b9\u5230\u6700\u8fdc\u53f6\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\u3002
    • \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\u3002
    • \u8282\u70b9\u7684\u300c\u9ad8\u5ea6 height\u300d\uff1a\u4ece\u8ddd\u79bb\u8be5\u8282\u70b9\u6700\u8fdc\u7684\u53f6\u8282\u70b9\u5230\u8be5\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\u3002

    \u56fe 7-2 \u00a0 \u4e8c\u53c9\u6811\u7684\u5e38\u7528\u672f\u8bed

    Tip

    \u8bf7\u6ce8\u610f\uff0c\u6211\u4eec\u901a\u5e38\u5c06\u201c\u9ad8\u5ea6\u201d\u548c\u201c\u6df1\u5ea6\u201d\u5b9a\u4e49\u4e3a\u201c\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\u201d\uff0c\u4f46\u6709\u4e9b\u9898\u76ee\u6216\u6559\u6750\u53ef\u80fd\u4f1a\u5c06\u5176\u5b9a\u4e49\u4e3a\u201c\u7ecf\u8fc7\u7684\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":""},{"location":"chapter_tree/binary_tree/#1","title":"1. \u00a0 \u521d\u59cb\u5316\u4e8c\u53c9\u6811","text":"

    \u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u9996\u5148\u521d\u59cb\u5316\u8282\u70b9\uff0c\u7136\u540e\u6784\u5efa\u5f15\u7528\uff08\u6307\u9488\uff09\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.rs
    // \u521d\u59cb\u5316\u8282\u70b9\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    binary_tree.kt
    // \u521d\u59cb\u5316\u8282\u70b9\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.rb
    \n
    binary_tree.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/binary_tree/#2","title":"2. \u00a0 \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9","text":"

    \u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u5728\u4e8c\u53c9\u6811\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u53ef\u4ee5\u901a\u8fc7\u4fee\u6539\u6307\u9488\u6765\u5b9e\u73b0\u3002\u56fe 7-3 \u7ed9\u51fa\u4e86\u4e00\u4e2a\u793a\u4f8b\u3002

    \u56fe 7-3 \u00a0 \u5728\u4e8c\u53c9\u6811\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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.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.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.cs
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode P = new(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.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.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.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
    binary_tree.rs
    let p = TreeNode::new(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// \u5220\u9664\u8282\u70b9 p\nn1.borrow_mut().left = Some(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.kt
    val P = 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.rb
    \n
    binary_tree.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    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\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_1","title":"1. \u00a0 \u5b8c\u7f8e\u4e8c\u53c9\u6811","text":"

    \u5982\u56fe 7-4 \u6240\u793a\uff0c\u300c\u5b8c\u7f8e\u4e8c\u53c9\u6811 perfect binary tree\u300d\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\u7684\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

    \u8bf7\u6ce8\u610f\uff0c\u5728\u4e2d\u6587\u793e\u533a\u4e2d\uff0c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u5e38\u88ab\u79f0\u4e3a\u300c\u6ee1\u4e8c\u53c9\u6811\u300d\u3002

    \u56fe 7-4 \u00a0 \u5b8c\u7f8e\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#2_1","title":"2. \u00a0 \u5b8c\u5168\u4e8c\u53c9\u6811","text":"

    \u5982\u56fe 7-5 \u6240\u793a\uff0c\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

    \u56fe 7-5 \u00a0 \u5b8c\u5168\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#3","title":"3. \u00a0 \u5b8c\u6ee1\u4e8c\u53c9\u6811","text":"

    \u5982\u56fe 7-6 \u6240\u793a\uff0c\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

    \u56fe 7-6 \u00a0 \u5b8c\u6ee1\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#4","title":"4. \u00a0 \u5e73\u8861\u4e8c\u53c9\u6811","text":"

    \u5982\u56fe 7-7 \u6240\u793a\uff0c\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

    \u56fe 7-7 \u00a0 \u5e73\u8861\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#714","title":"7.1.4 \u00a0 \u4e8c\u53c9\u6811\u7684\u9000\u5316","text":"

    \u56fe 7-8 \u5c55\u793a\u4e86\u4e8c\u53c9\u6811\u7684\u7406\u60f3\u7ed3\u6784\u4e0e\u9000\u5316\u7ed3\u6784\u3002\u5f53\u4e8c\u53c9\u6811\u7684\u6bcf\u5c42\u8282\u70b9\u90fd\u88ab\u586b\u6ee1\u65f6\uff0c\u8fbe\u5230\u201c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u201d\uff1b\u800c\u5f53\u6240\u6709\u8282\u70b9\u90fd\u504f\u5411\u4e00\u4fa7\u65f6\uff0c\u4e8c\u53c9\u6811\u9000\u5316\u4e3a\u201c\u94fe\u8868\u201d\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\u3002
    • \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)\\) \u3002

    \u56fe 7-8 \u00a0 \u4e8c\u53c9\u6811\u7684\u6700\u4f73\u7ed3\u6784\u4e0e\u6700\u5dee\u7ed3\u6784

    \u5982\u8868 7-1 \u6240\u793a\uff0c\u5728\u6700\u4f73\u7ed3\u6784\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\u503c\u6216\u6781\u5c0f\u503c\u3002

    \u8868 7-1 \u00a0 \u4e8c\u53c9\u6811\u7684\u6700\u4f73\u7ed3\u6784\u4e0e\u6700\u5dee\u7ed3\u6784

    \u5b8c\u7f8e\u4e8c\u53c9\u6811 \u94fe\u8868 \u7b2c \\(i\\) \u5c42\u7684\u8282\u70b9\u6570\u91cf \\(2^{i-1}\\) \\(1\\) \u9ad8\u5ea6\u4e3a \\(h\\) \u7684\u6811\u7684\u53f6\u8282\u70b9\u6570\u91cf \\(2^h\\) \\(1\\) \u9ad8\u5ea6\u4e3a \\(h\\) \u7684\u6811\u7684\u8282\u70b9\u603b\u6570 \\(2^{h+1} - 1\\) \\(h + 1\\) \u8282\u70b9\u603b\u6570\u4e3a \\(n\\) \u7684\u6811\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":"

    \u5982\u56fe 7-9 \u6240\u793a\uff0c\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\u904d\u5386 breadth-first traversal\u300d\uff0c\u4e5f\u79f0\u300c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22 breadth-first search, BFS\u300d\uff0c\u5b83\u4f53\u73b0\u4e86\u4e00\u79cd\u201c\u4e00\u5708\u4e00\u5708\u5411\u5916\u6269\u5c55\u201d\u7684\u9010\u5c42\u904d\u5386\u65b9\u5f0f\u3002

    \u56fe 7-9 \u00a0 \u4e8c\u53c9\u6811\u7684\u5c42\u5e8f\u904d\u5386

    "},{"location":"chapter_tree/binary_tree_traversal/#1","title":"1. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u901a\u5e38\u501f\u52a9\u201c\u961f\u5217\u201d\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\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # \u961f\u5217\u51fa\u961f\n        res.append(node.val)  # \u4fdd\u5b58\u8282\u70b9\u503c\n        if node.left is not None:\n            queue.append(node.left)  # \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if node.right is not None:\n            queue.append(node.right)  # \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    return res\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\n    queue<TreeNode *> queue;\n    queue.push(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    vector<int> vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // \u961f\u5217\u51fa\u961f\n        vec.push_back(node->val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node->left != nullptr)\n            queue.push(node->left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node->right != nullptr)\n            queue.push(node->right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return vec;\n}\n
    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\n    Queue<TreeNode> queue = new LinkedList<>();\n    queue.add(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    List<Integer> list = new ArrayList<>();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // \u961f\u5217\u51fa\u961f\n        list.add(node.val);           // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null)\n            queue.offer(node.left);   // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right != null)\n            queue.offer(node.right);  // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list;\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\n    Queue<TreeNode> queue = new();\n    queue.Enqueue(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    List<int> list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // \u961f\u5217\u51fa\u961f\n        list.Add(node.val!.Value);       // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null)\n            queue.Enqueue(node.left);    // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right != null)\n            queue.Enqueue(node.right);   // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list;\n}\n
    binary_tree_bfs.go
    /* \u5c42\u5e8f\u904d\u5386 */\nfunc levelOrder(root *TreeNode) []any {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    queue := list.New()\n    queue.PushBack(root)\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5207\u7247\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    nums := make([]any, 0)\n    for queue.Len() > 0 {\n        // \u961f\u5217\u51fa\u961f\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // \u4fdd\u5b58\u8282\u70b9\u503c\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\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\n    var queue: [TreeNode] = [root]\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // \u961f\u5217\u51fa\u961f\n        list.append(node.val) // \u4fdd\u5b58\u8282\u70b9\u503c\n        if let left = node.left {\n            queue.append(left) // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if let right = node.right {\n            queue.append(right) // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }\n    }\n    return list\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\n    const queue = [root];\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // \u961f\u5217\u51fa\u961f\n        list.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left) queue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right) queue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return 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\n    const queue = [root];\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // \u961f\u5217\u51fa\u961f\n        list.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left) {\n            queue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if (node.right) {\n            queue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }\n    }\n    return 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\n  Queue<TreeNode?> queue = Queue();\n  queue.add(root);\n  // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n  List<int> res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // \u961f\u5217\u51fa\u961f\n    res.add(node!.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n    if (node.left != null) queue.add(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n    if (node.right != null) queue.add(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n  }\n  return res;\n}\n
    binary_tree_bfs.rs
    /* \u5c42\u5e8f\u904d\u5386 */\nfn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    let mut que = VecDeque::new();\n    que.push_back(Rc::clone(&root));\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // \u961f\u5217\u51fa\u961f\n        vec.push(node.borrow().val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(Rc::clone(left)); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(Rc::clone(right)); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        };\n    }\n    vec\n}\n
    binary_tree_bfs.c
    /* \u5c42\u5e8f\u904d\u5386 */\nint *levelOrder(TreeNode *root, int *size) {\n    /* \u8f85\u52a9\u961f\u5217 */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* \u8f85\u52a9\u961f\u5217 */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // \u961f\u5217\u6307\u9488\n    front = 0, rear = 0;\n    // \u52a0\u5165\u6839\u8282\u70b9\n    queue[rear++] = root;\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    /* \u8f85\u52a9\u6570\u7ec4 */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // \u6570\u7ec4\u6307\u9488\n    index = 0;\n    while (front < rear) {\n        // \u961f\u5217\u51fa\u961f\n        node = queue[front++];\n        // \u4fdd\u5b58\u8282\u70b9\u503c\n        arr[index++] = node->val;\n        if (node->left != NULL) {\n            // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n            queue[rear++] = node->left;\n        }\n        if (node->right != NULL) {\n            // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n            queue[rear++] = node->right;\n        }\n    }\n    // \u66f4\u65b0\u6570\u7ec4\u957f\u5ea6\u7684\u503c\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // \u91ca\u653e\u8f85\u52a9\u6570\u7ec4\u7a7a\u95f4\n    free(queue);\n    return arr;\n}\n
    binary_tree_bfs.kt
    /* \u5c42\u5e8f\u904d\u5386 */\nfun levelOrder(root: TreeNode?): MutableList<Int> {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    val queue = LinkedList<TreeNode?>()\n    queue.add(root)\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    val list = ArrayList<Int>()\n    while (!queue.isEmpty()) {\n        val node = queue.poll() // \u961f\u5217\u51fa\u961f\n        list.add(node?.value!!) // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null) queue.offer(node.left) // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n\n        if (node.right != null) queue.offer(node.right) // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list\n}\n
    binary_tree_bfs.rb
    [class]{}-[func]{level_order}\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\n    const L = std.TailQueue(*inc.TreeNode(T));\n    var queue = L{};\n    var root_node = try mem_allocator.create(L.Node);\n    root_node.data = root;\n    queue.append(root_node); \n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    var list = std.ArrayList(T).init(std.heap.page_allocator);\n    while (queue.len > 0) {\n        var queue_node = queue.popFirst().?;    // \u961f\u5217\u51fa\u961f\n        var node = queue_node.data;\n        try list.append(node.val);              // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null) {\n            var tmp_node = try mem_allocator.create(L.Node);\n            tmp_node.data = node.left.?;\n            queue.append(tmp_node);             // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if (node.right != null) {\n            var tmp_node = try mem_allocator.create(L.Node);\n            tmp_node.data = node.right.?;\n            queue.append(tmp_node);             // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }        \n    }\n    return list;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/binary_tree_traversal/#2","title":"2. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \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\u4e3a \\(O(n)\\) \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 \\((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\u4e5f\u79f0\u300c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22 depth-first search, DFS\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

    \u56fe 7-10 \u5c55\u793a\u4e86\u5bf9\u4e8c\u53c9\u6811\u8fdb\u884c\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u5de5\u4f5c\u539f\u7406\u3002\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u5c31\u50cf\u662f\u7ed5\u7740\u6574\u68f5\u4e8c\u53c9\u6811\u7684\u5916\u56f4\u201c\u8d70\u201d\u4e00\u5708\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

    \u56fe 7-10 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386

    "},{"location":"chapter_tree/binary_tree_traversal/#1_1","title":"1. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u5b9e\u73b0\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_tree_dfs.py
    def pre_order(root: TreeNode | None):\n    \"\"\"\u524d\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"\u4e2d\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"\u540e\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n
    binary_tree_dfs.cpp
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    vec.push_back(root->val);\n    preOrder(root->left);\n    preOrder(root->right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root->left);\n    vec.push_back(root->val);\n    inOrder(root->right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root->left);\n    postOrder(root->right);\n    vec.push_back(root->val);\n}\n
    binary_tree_dfs.java
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n
    binary_tree_dfs.cs
    /* \u524d\u5e8f\u904d\u5386 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n
    binary_tree_dfs.go
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n
    binary_tree_dfs.swift
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n
    binary_tree_dfs.js
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n
    binary_tree_dfs.ts
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n
    binary_tree_dfs.dart
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n
    binary_tree_dfs.rs
    /* \u524d\u5e8f\u904d\u5386 */\nfn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n        result.push(node.borrow().val);\n        result.append(&mut pre_order(node.borrow().left.as_ref()));\n        result.append(&mut pre_order(node.borrow().right.as_ref()));\n    }\n    result\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n        result.append(&mut in_order(node.borrow().left.as_ref()));\n        result.push(node.borrow().val);\n        result.append(&mut in_order(node.borrow().right.as_ref()));\n    }\n    result\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n        result.append(&mut post_order(node.borrow().left.as_ref()));\n        result.append(&mut post_order(node.borrow().right.as_ref()));\n        result.push(node.borrow().val);\n    }\n    result\n}\n
    binary_tree_dfs.c
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    arr[(*size)++] = root->val;\n    preOrder(root->left, size);\n    preOrder(root->right, size);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root->left, size);\n    arr[(*size)++] = root->val;\n    inOrder(root->right, size);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root->left, size);\n    postOrder(root->right, size);\n    arr[(*size)++] = root->val;\n}\n
    binary_tree_dfs.kt
    /* \u524d\u5e8f\u904d\u5386 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.add(root.value)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left)\n    list.add(root.value)\n    inOrder(root.right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root.value)\n}\n
    binary_tree_dfs.rb
    [class]{}-[func]{pre_order}\n\n[class]{}-[func]{in_order}\n\n[class]{}-[func]{post_order}\n
    binary_tree_dfs.zig
    // \u524d\u5e8f\u904d\u5386\nfn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    try list.append(root.?.val);\n    try preOrder(T, root.?.left);\n    try preOrder(T, root.?.right);\n}\n\n// \u4e2d\u5e8f\u904d\u5386\nfn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    try inOrder(T, root.?.left);\n    try list.append(root.?.val);\n    try inOrder(T, root.?.right);\n}\n\n// \u540e\u5e8f\u904d\u5386\nfn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    try postOrder(T, root.?.left);\n    try postOrder(T, root.?.right);\n    try list.append(root.?.val);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    Tip

    \u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u4e5f\u53ef\u4ee5\u57fa\u4e8e\u8fed\u4ee3\u5b9e\u73b0\uff0c\u6709\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u81ea\u884c\u7814\u7a76\u3002

    \u56fe 7-11 \u5c55\u793a\u4e86\u524d\u5e8f\u904d\u5386\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u8fc7\u7a0b\uff0c\u5176\u53ef\u5206\u4e3a\u201c\u9012\u201d\u548c\u201c\u5f52\u201d\u4e24\u4e2a\u9006\u5411\u7684\u90e8\u5206\u3002

    1. \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\u3002
    2. \u201c\u5f52\u201d\u8868\u793a\u51fd\u6570\u8fd4\u56de\uff0c\u4ee3\u8868\u5f53\u524d\u8282\u70b9\u5df2\u7ecf\u8bbf\u95ee\u5b8c\u6bd5\u3002
    <1><2><3><4><5><6><7><8><9><10><11>

    \u56fe 7-11 \u00a0 \u524d\u5e8f\u904d\u5386\u7684\u9012\u5f52\u8fc7\u7a0b

    "},{"location":"chapter_tree/binary_tree_traversal/#2_1","title":"2. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1a\u6240\u6709\u8282\u70b9\u88ab\u8bbf\u95ee\u4e00\u6b21\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \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":""},{"location":"chapter_tree/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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\u5b8c\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\u6269\u5c55\u201d\u7684\u9010\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\u5148\u8d70\u5230\u5c3d\u5934\uff0c\u518d\u56de\u6eaf\u7ee7\u7eed\u201d\u7684\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\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\u5b83\u901a\u8fc7\u65cb\u8f6c\u64cd\u4f5c\u786e\u4fdd\u5728\u4e0d\u65ad\u63d2\u5165\u548c\u5220\u9664\u8282\u70b9\u540e\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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\u201d\u3002

    Q\uff1a\u4e8c\u53c9\u6811\u4e2d\u7684\u63d2\u5165\u4e0e\u5220\u9664\u4e00\u822c\u7531\u4e00\u5957\u64cd\u4f5c\u914d\u5408\u5b8c\u6210\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\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

    Q\uff1a\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

    \u4e0e\u987a\u5e8f\u548c\u9006\u5e8f\u904d\u5386\u6570\u7ec4\u7c7b\u4f3c\uff0c\u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386\u662f\u4e09\u79cd\u4e8c\u53c9\u6811\u904d\u5386\u65b9\u6cd5\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u5b83\u4eec\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\u8282\u70b9\u5927\u5c0f\u6ee1\u8db3 \u5de6\u5b50\u8282\u70b9\u503c < \u6839\u8282\u70b9\u503c < \u53f3\u5b50\u8282\u70b9\u503c \uff0c\u56e0\u6b64\u6211\u4eec\u53ea\u8981\u6309\u7167\u201c\u5de6 \\(\\rightarrow\\) \u6839 \\(\\rightarrow\\) \u53f3\u201d\u7684\u4f18\u5148\u7ea7\u904d\u5386\u6811\uff0c\u5c31\u53ef\u4ee5\u83b7\u5f97\u6709\u5e8f\u7684\u8282\u70b9\u5e8f\u5217\u3002

    Q\uff1a\u53f3\u65cb\u64cd\u4f5c\u662f\u5904\u7406\u5931\u8861\u8282\u70b9 node\u3001child\u3001grand_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

    Q\uff1a\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\u8282\u70b9\u9ad8\u5ea6\uff0c\u7c7b\u4f3c\u4e8e vector.size() \uff0c\u56e0\u6b64\u8bbe\u7f6e\u6210 public \u4ee5\u4fbf\u4f7f\u7528\u3002

    Q\uff1a\u5982\u4f55\u4ece\u4e00\u7ec4\u8f93\u5165\u6570\u636e\u6784\u5efa\u4e00\u68f5\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\u5df2\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4ee3\u7801\u4e2d\u7684 build_tree() \u65b9\u6cd5\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\u5c06\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

    Q\uff1a\u5728 Java \u4e2d\uff0c\u5b57\u7b26\u4e32\u5bf9\u6bd4\u662f\u5426\u4e00\u5b9a\u8981\u7528 equals() \u65b9\u6cd5\uff1f

    \u5728 Java \u4e2d\uff0c\u5bf9\u4e8e\u57fa\u672c\u6570\u636e\u7c7b\u578b\uff0c== \u7528\u4e8e\u5bf9\u6bd4\u4e24\u4e2a\u53d8\u91cf\u7684\u503c\u662f\u5426\u76f8\u7b49\u3002\u5bf9\u4e8e\u5f15\u7528\u7c7b\u578b\uff0c\u4e24\u79cd\u7b26\u53f7\u7684\u5de5\u4f5c\u539f\u7406\u662f\u4e0d\u540c\u7684\u3002

    • == \uff1a\u7528\u6765\u6bd4\u8f83\u4e24\u4e2a\u53d8\u91cf\u662f\u5426\u6307\u5411\u540c\u4e00\u4e2a\u5bf9\u8c61\uff0c\u5373\u5b83\u4eec\u5728\u5185\u5b58\u4e2d\u7684\u4f4d\u7f6e\u662f\u5426\u76f8\u540c\u3002
    • equals()\uff1a\u7528\u6765\u5bf9\u6bd4\u4e24\u4e2a\u5bf9\u8c61\u7684\u503c\u662f\u5426\u76f8\u7b49\u3002

    \u56e0\u6b64\uff0c\u5982\u679c\u8981\u5bf9\u6bd4\u503c\uff0c\u6211\u4eec\u5e94\u8be5\u4f7f\u7528 equals() \u3002\u7136\u800c\uff0c\u901a\u8fc7 String a = \"hi\"; String b = \"hi\"; \u521d\u59cb\u5316\u7684\u5b57\u7b26\u4e32\u90fd\u5b58\u50a8\u5728\u5b57\u7b26\u4e32\u5e38\u91cf\u6c60\u4e2d\uff0c\u5b83\u4eec\u6307\u5411\u540c\u4e00\u4e2a\u5bf9\u8c61\uff0c\u56e0\u6b64\u4e5f\u53ef\u4ee5\u7528 a == b \u6765\u6bd4\u8f83\u4e24\u4e2a\u5b57\u7b26\u4e32\u7684\u5185\u5bb9\u3002

    Q\uff1a\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u5230\u6700\u5e95\u5c42\u4e4b\u524d\uff0c\u961f\u5217\u4e2d\u7684\u8282\u70b9\u6570\u91cf\u662f \\(2^h\\) \u5417\uff1f

    \u662f\u7684\uff0c\u4f8b\u5982\u9ad8\u5ea6 \\(h = 2\\) \u7684\u6ee1\u4e8c\u53c9\u6811\uff0c\u5176\u8282\u70b9\u603b\u6570 \\(n = 7\\) \uff0c\u5219\u5e95\u5c42\u8282\u70b9\u6570\u91cf \\(4 = 2^h = (n + 1) / 2\\) \u3002

    "}]} \ No newline at end of file +{"config":{"lang":["en"],"separator":"[\\s\\u200b\\u3000\\-\u3001\u3002\uff0c\uff0e\uff1f\uff01\uff1b]+","pipeline":["stemmer"]},"docs":[{"location":"chapter_appendix/","title":"\u7b2c 16 \u7ae0 \u00a0 \u9644\u5f55","text":""},{"location":"chapter_appendix/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 16.1 \u00a0 \u7f16\u7a0b\u73af\u5883\u5b89\u88c5
    • 16.2 \u00a0 \u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c
    • 16.3 \u00a0 \u672f\u8bed\u8868
    "},{"location":"chapter_appendix/contribution/","title":"16.2 \u00a0 \u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c","text":"

    \u7531\u4e8e\u7b14\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\u94fe\u63a5\u5931\u6548\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\u7ed9\u8bfb\u8005\u63d0\u4f9b\u66f4\u4f18\u8d28\u7684\u5b66\u4e60\u8d44\u6e90\u3002

    \u6240\u6709\u64b0\u7a3f\u4eba\u7684 GitHub ID \u5c06\u5728\u672c\u4e66\u4ed3\u5e93\u3001\u7f51\u9875\u7248\u548c PDF \u7248\u7684\u4e3b\u9875\u4e0a\u8fdb\u884c\u5c55\u793a\uff0c\u4ee5\u611f\u8c22\u4ed6\u4eec\u5bf9\u5f00\u6e90\u793e\u533a\u7684\u65e0\u79c1\u5949\u732e\u3002

    \u5f00\u6e90\u7684\u9b45\u529b

    \u7eb8\u8d28\u56fe\u4e66\u7684\u4e24\u6b21\u5370\u5237\u7684\u95f4\u9694\u65f6\u95f4\u5f80\u5f80\u8f83\u4e45\uff0c\u5185\u5bb9\u66f4\u65b0\u975e\u5e38\u4e0d\u65b9\u4fbf\u3002

    \u800c\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

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

    \u5982\u56fe 16-3 \u6240\u793a\uff0c\u6bcf\u4e2a\u9875\u9762\u7684\u53f3\u4e0a\u89d2\u90fd\u6709\u201c\u7f16\u8f91\u56fe\u6807\u201d\u3002\u60a8\u53ef\u4ee5\u6309\u7167\u4ee5\u4e0b\u6b65\u9aa4\u4fee\u6539\u6587\u672c\u6216\u4ee3\u7801\u3002

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

    \u56fe 16-3 \u00a0 \u9875\u9762\u7f16\u8f91\u6309\u952e

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

    "},{"location":"chapter_appendix/contribution/#2","title":"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\u4ee5\u4e0b Pull Request \u5de5\u4f5c\u6d41\u7a0b\u3002

    1. \u767b\u5f55 GitHub \uff0c\u5c06\u672c\u4e66\u7684\u4ee3\u7801\u4ed3\u5e93 Fork \u5230\u4e2a\u4eba\u8d26\u53f7\u4e0b\u3002
    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\u3002
    3. \u5728\u672c\u5730\u8fdb\u884c\u5185\u5bb9\u521b\u4f5c\uff0c\u5e76\u8fdb\u884c\u5b8c\u6574\u6d4b\u8bd5\uff0c\u9a8c\u8bc1\u4ee3\u7801\u7684\u6b63\u786e\u6027\u3002
    4. \u5c06\u672c\u5730\u6240\u505a\u66f4\u6539 Commit \uff0c\u7136\u540e Push \u81f3\u8fdc\u7a0b\u4ed3\u5e93\u3002
    5. \u5237\u65b0\u4ed3\u5e93\u7f51\u9875\uff0c\u70b9\u51fb\u201cCreate pull request\u201d\u6309\u94ae\u5373\u53ef\u53d1\u8d77\u62c9\u53d6\u8bf7\u6c42\u3002
    "},{"location":"chapter_appendix/contribution/#3-docker","title":"3. \u00a0 Docker \u90e8\u7f72","text":"

    \u5728 hello-algo \u6839\u76ee\u5f55\u4e0b\uff0c\u6267\u884c\u4ee5\u4e0b Docker \u811a\u672c\uff0c\u5373\u53ef\u5728 http://localhost:8000 \u8bbf\u95ee\u672c\u9879\u76ee\uff1a

    docker-compose up -d\n

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

    docker-compose down\n
    "},{"location":"chapter_appendix/installation/","title":"16.1 \u00a0 \u7f16\u7a0b\u73af\u5883\u5b89\u88c5","text":""},{"location":"chapter_appendix/installation/#1611-ide","title":"16.1.1 \u00a0 \u5b89\u88c5 IDE","text":"

    \u63a8\u8350\u4f7f\u7528\u5f00\u6e90\u3001\u8f7b\u91cf\u7684 VS Code \u4f5c\u4e3a\u672c\u5730\u96c6\u6210\u5f00\u53d1\u73af\u5883\uff08IDE\uff09\u3002\u8bbf\u95ee VS Code \u5b98\u7f51\uff0c\u6839\u636e\u64cd\u4f5c\u7cfb\u7edf\u9009\u62e9\u76f8\u5e94\u7248\u672c\u7684 VS Code \u8fdb\u884c\u4e0b\u8f7d\u548c\u5b89\u88c5\u3002

    \u56fe 16-1 \u00a0 \u4ece\u5b98\u7f51\u4e0b\u8f7d VS Code

    VS Code \u62e5\u6709\u5f3a\u5927\u7684\u6269\u5c55\u5305\u751f\u6001\u7cfb\u7edf\uff0c\u652f\u6301\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u7684\u8fd0\u884c\u548c\u8c03\u8bd5\u3002\u4ee5 Python \u4e3a\u4f8b\uff0c\u5b89\u88c5\u201cPython Extension Pack\u201d\u6269\u5c55\u5305\u4e4b\u540e\uff0c\u5373\u53ef\u8fdb\u884c Python \u4ee3\u7801\u8c03\u8bd5\u3002\u5b89\u88c5\u6b65\u9aa4\u5982\u56fe 16-2 \u6240\u793a\u3002

    \u56fe 16-2 \u00a0 \u5b89\u88c5 VS Code \u6269\u5c55\u5305

    "},{"location":"chapter_appendix/installation/#1612","title":"16.1.2 \u00a0 \u5b89\u88c5\u8bed\u8a00\u73af\u5883","text":""},{"location":"chapter_appendix/installation/#1-python","title":"1. \u00a0 Python \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Miniconda3 \uff0c\u9700\u8981 Python 3.10 \u6216\u66f4\u65b0\u7248\u672c\u3002
    2. \u5728 VS Code \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/#2-cc","title":"2. \u00a0 C/C++ \u73af\u5883","text":"
    1. Windows \u7cfb\u7edf\u9700\u8981\u5b89\u88c5 MinGW\uff08\u914d\u7f6e\u6559\u7a0b\uff09\uff1bMacOS \u81ea\u5e26 Clang \uff0c\u65e0\u987b\u5b89\u88c5\u3002
    2. \u5728 VS Code \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/#3-java","title":"3. \u00a0 Java \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 OpenJDK\uff08\u7248\u672c\u9700\u6ee1\u8db3 > JDK 9\uff09\u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 java \uff0c\u5b89\u88c5 Extension Pack for Java \u3002
    "},{"location":"chapter_appendix/installation/#4-c","title":"4. \u00a0 C# \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 .Net 8.0 \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 C# Dev Kit \uff0c\u5b89\u88c5 C# Dev Kit \uff08\u914d\u7f6e\u6559\u7a0b\uff09\u3002
    3. \u4e5f\u53ef\u4f7f\u7528 Visual Studio\uff08\u5b89\u88c5\u6559\u7a0b\uff09\u3002
    "},{"location":"chapter_appendix/installation/#5-go","title":"5. \u00a0 Go \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 go \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 go \uff0c\u5b89\u88c5 Go \u3002
    3. \u6309\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/#6-swift","title":"6. \u00a0 Swift \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Swift \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 swift \uff0c\u5b89\u88c5 Swift for Visual Studio Code \u3002
    "},{"location":"chapter_appendix/installation/#7-javascript","title":"7. \u00a0 JavaScript \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 node.js \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 javascript \uff0c\u5b89\u88c5 JavaScript (ES6) code snippets \u3002
    3. \uff08\u53ef\u9009\uff09\u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 Prettier \uff0c\u5b89\u88c5\u4ee3\u7801\u683c\u5f0f\u5316\u5de5\u5177\u3002
    "},{"location":"chapter_appendix/installation/#8-dart","title":"8. \u00a0 Dart \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Dart \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 dart \uff0c\u5b89\u88c5 Dart \u3002
    "},{"location":"chapter_appendix/installation/#9-rust","title":"9. \u00a0 Rust \u73af\u5883","text":"
    1. \u4e0b\u8f7d\u5e76\u5b89\u88c5 Rust \u3002
    2. \u5728 VS Code \u7684\u63d2\u4ef6\u5e02\u573a\u4e2d\u641c\u7d22 rust \uff0c\u5b89\u88c5 rust-analyzer \u3002
    "},{"location":"chapter_appendix/terminology/","title":"16.3 \u00a0 \u672f\u8bed\u8868","text":"

    \u8868 16-1 \u5217\u51fa\u4e86\u4e66\u4e2d\u51fa\u73b0\u7684\u91cd\u8981\u672f\u8bed\uff0c\u503c\u5f97\u6ce8\u610f\u4ee5\u4e0b\u51e0\u70b9\u3002

    • \u5efa\u8bae\u8bb0\u4f4f\u540d\u8bcd\u7684\u82f1\u6587\u53eb\u6cd5\uff0c\u4ee5\u4fbf\u9605\u8bfb\u82f1\u6587\u6587\u732e\u3002
    • \u90e8\u5206\u540d\u8bcd\u5728\u7b80\u4f53\u4e2d\u6587\u548c\u7e41\u4f53\u4e2d\u6587\u4e0b\u7684\u53eb\u6cd5\u4e0d\u540c\u3002

    \u8868 16-1 \u00a0 \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u91cd\u8981\u540d\u8bcd

    English \u7b80\u4f53\u4e2d\u6587 \u7e41\u4f53\u4e2d\u6587 algorithm \u7b97\u6cd5 \u6f14\u7b97\u6cd5 data structure \u6570\u636e\u7ed3\u6784 \u8cc7\u6599\u7d50\u69cb code \u4ee3\u7801 \u7a0b\u5f0f\u78bc file \u6587\u4ef6 \u6a94\u6848 function \u51fd\u6570 \u51fd\u5f0f method \u65b9\u6cd5 \u65b9\u6cd5 variable \u53d8\u91cf \u8b8a\u6578 asymptotic complexity analysis \u6e10\u8fd1\u590d\u6742\u5ea6\u5206\u6790 \u6f38\u8fd1\u8907\u96dc\u5ea6\u5206\u6790 time complexity \u65f6\u95f4\u590d\u6742\u5ea6 \u6642\u9593\u8907\u96dc\u5ea6 space complexity \u7a7a\u95f4\u590d\u6742\u5ea6 \u7a7a\u9593\u8907\u96dc\u5ea6 loop \u5faa\u73af \u8ff4\u5708 iteration \u8fed\u4ee3 \u8fed\u4ee3 recursion \u9012\u5f52 \u905e\u8ff4 tail recursion \u5c3e\u9012\u5f52 \u5c3e\u905e\u8ff4 recursion tree \u9012\u5f52\u6811 \u905e\u8ff4\u6a39 big-\\(O\\) notation \u5927 \\(O\\) \u8bb0\u53f7 \u5927 \\(O\\) \u8a18\u865f asymptotic upper bound \u6e10\u8fd1\u4e0a\u754c \u6f38\u8fd1\u4e0a\u754c sign-magnitude \u539f\u7801 \u539f\u78bc 1\u2019s complement \u53cd\u7801 \u53cd\u78bc 2\u2019s complement \u8865\u7801 \u88dc\u78bc array \u6570\u7ec4 \u9663\u5217 index \u7d22\u5f15 \u7d22\u5f15 linked list \u94fe\u8868 \u93c8\u7d50\u4e32\u5217 linked list node, list node \u94fe\u8868\u8282\u70b9 \u93c8\u7d50\u4e32\u5217\u7bc0\u9ede head node \u5934\u8282\u70b9 \u982d\u7bc0\u9ede tail node \u5c3e\u8282\u70b9 \u5c3e\u7bc0\u9ede list \u5217\u8868 \u5217\u8868 dynamic array \u52a8\u6001\u6570\u7ec4 \u52d5\u614b\u9663\u5217 hard disk \u786c\u76d8 \u786c\u789f random-access memory (RAM) \u5185\u5b58 \u5167\u5b58 cache memory \u7f13\u5b58 \u5feb\u53d6 cache miss \u7f13\u5b58\u672a\u547d\u4e2d \u5feb\u53d6\u672a\u547d\u4e2d cache hit rate \u7f13\u5b58\u547d\u4e2d\u7387 \u5feb\u53d6\u547d\u4e2d\u7387 stack \u6808 \u5806\u758a top of the stack \u6808\u9876 \u5806\u758a\u9802 bottom of the stack \u6808\u5e95 \u5806\u758a\u5e95 queue \u961f\u5217 \u4f47\u5217 double-ended queue \u53cc\u5411\u961f\u5217 \u96d9\u5411\u4f47\u5217 front of the queue \u961f\u9996 \u4f47\u5217\u9996 rear of the queue \u961f\u5c3e \u4f47\u5217\u5c3e hash table \u54c8\u5e0c\u8868 \u96dc\u6e4a\u8868 bucket \u6876 \u6876 hash function \u54c8\u5e0c\u51fd\u6570 \u96dc\u6e4a\u51fd\u5f0f hash collision \u54c8\u5e0c\u51b2\u7a81 \u96dc\u6e4a\u885d\u7a81 load factor \u8d1f\u8f7d\u56e0\u5b50 \u8ca0\u8f09\u56e0\u5b50 separate chaining \u94fe\u5f0f\u5730\u5740 \u93c8\u7d50\u4f4d\u5740 open addressing \u5f00\u653e\u5bfb\u5740 \u958b\u653e\u5b9a\u5740 linear probing \u7ebf\u6027\u63a2\u6d4b \u7dda\u6027\u63a2\u67e5 lazy deletion \u61d2\u5220\u9664 \u61f6\u522a\u9664 binary tree \u4e8c\u53c9\u6811 \u4e8c\u5143\u6a39 tree node \u6811\u8282\u70b9 \u6a39\u7bc0\u9ede left-child node \u5de6\u5b50\u8282\u70b9 \u5de6\u5b50\u7bc0\u9ede right-child node \u53f3\u5b50\u8282\u70b9 \u53f3\u5b50\u7bc0\u9ede parent node \u7236\u8282\u70b9 \u7236\u7bc0\u9ede left subtree \u5de6\u5b50\u6811 \u5de6\u5b50\u6a39 right subtree \u53f3\u5b50\u6811 \u53f3\u5b50\u6a39 root node \u6839\u8282\u70b9 \u6839\u7bc0\u9ede leaf node \u53f6\u8282\u70b9 \u8449\u7bc0\u9ede edge \u8fb9 \u908a level \u5c42 \u5c64 degree \u5ea6 \u5ea6 height \u9ad8\u5ea6 \u9ad8\u5ea6 depth \u6df1\u5ea6 \u6df1\u5ea6 perfect binary tree \u5b8c\u7f8e\u4e8c\u53c9\u6811 \u5b8c\u7f8e\u4e8c\u5143\u6a39 complete binary tree \u5b8c\u5168\u4e8c\u53c9\u6811 \u5b8c\u5168\u4e8c\u5143\u6a39 full binary tree \u5b8c\u6ee1\u4e8c\u53c9\u6811 \u5b8c\u6eff\u4e8c\u5143\u6a39 balanced binary tree \u5e73\u8861\u4e8c\u53c9\u6811 \u5e73\u8861\u4e8c\u5143\u6a39 binary search tree \u4e8c\u53c9\u641c\u7d22\u6811 \u4e8c\u5143\u641c\u5c0b\u6a39 AVL tree AVL \u6811 AVL \u6a39 red-black tree \u7ea2\u9ed1\u6811 \u7d05\u9ed1\u6a39 level-order traversal \u5c42\u5e8f\u904d\u5386 \u5c64\u5e8f\u8d70\u8a2a breadth-first traversal \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 \u5ee3\u5ea6\u512a\u5148\u8d70\u8a2a depth-first traversal \u6df1\u5ea6\u4f18\u5148\u904d\u5386 \u6df1\u5ea6\u512a\u5148\u8d70\u8a2a binary search tree \u4e8c\u53c9\u641c\u7d22\u6811 \u4e8c\u5143\u641c\u5c0b\u6a39 balanced binary search tree \u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811 \u5e73\u8861\u4e8c\u5143\u641c\u5c0b\u6a39 balance factor \u5e73\u8861\u56e0\u5b50 \u5e73\u8861\u56e0\u5b50 heap \u5806 \u5806\u7a4d max heap \u5927\u9876\u5806 \u5927\u9802\u5806\u7a4d min heap \u5c0f\u9876\u5806 \u5c0f\u9802\u5806\u7a4d priority queue \u4f18\u5148\u961f\u5217 \u512a\u5148\u4f47\u5217 heapify \u5806\u5316 \u5806\u7a4d\u5316 top-\\(k\\) problem Top-\\(k\\) \u95ee\u9898 Top-\\(k\\) \u554f\u984c graph \u56fe \u5716 vertex \u9876\u70b9 \u9802\u9ede undirected graph \u65e0\u5411\u56fe \u7121\u5411\u5716 directed graph \u6709\u5411\u56fe \u6709\u5411\u5716 connected graph \u8fde\u901a\u56fe \u9023\u901a\u5716 disconnected graph \u975e\u8fde\u901a\u56fe \u975e\u9023\u901a\u5716 weighted graph \u6709\u6743\u56fe \u6709\u6b0a\u5716 adjacency \u90bb\u63a5 \u9130\u63a5 path \u8def\u5f84 \u8def\u5f91 in-degree \u5165\u5ea6 \u5165\u5ea6 out-degree \u51fa\u5ea6 \u51fa\u5ea6 adjacency matrix \u90bb\u63a5\u77e9\u9635 \u9130\u63a5\u77e9\u9663 adjacency list \u90bb\u63a5\u8868 \u9130\u63a5\u8868 breadth-first search \u5e7f\u5ea6\u4f18\u5148\u641c\u7d22 \u5ee3\u5ea6\u512a\u5148\u641c\u5c0b depth-first search \u6df1\u5ea6\u4f18\u5148\u641c\u7d22 \u6df1\u5ea6\u512a\u5148\u641c\u5c0b binary search \u4e8c\u5206\u67e5\u627e \u4e8c\u5206\u641c\u5c0b searching algorithm \u641c\u7d22\u7b97\u6cd5 \u641c\u5c0b\u6f14\u7b97\u6cd5 sorting algorithm \u6392\u5e8f\u7b97\u6cd5 \u6392\u5e8f\u6f14\u7b97\u6cd5 selection sort \u9009\u62e9\u6392\u5e8f \u9078\u64c7\u6392\u5e8f bubble sort \u5192\u6ce1\u6392\u5e8f \u6ce1\u6cab\u6392\u5e8f insertion sort \u63d2\u5165\u6392\u5e8f \u63d2\u5165\u6392\u5e8f quick sort \u5feb\u901f\u6392\u5e8f \u5feb\u901f\u6392\u5e8f merge sort \u5f52\u5e76\u6392\u5e8f \u5408\u4f75\u6392\u5e8f heap sort \u5806\u6392\u5e8f \u5806\u7a4d\u6392\u5e8f bucket sort \u6876\u6392\u5e8f \u6876\u6392\u5e8f counting sort \u8ba1\u6570\u6392\u5e8f \u8a08\u6578\u6392\u5e8f radix sort \u57fa\u6570\u6392\u5e8f \u57fa\u6578\u6392\u5e8f divide and conquer \u5206\u6cbb \u5206\u6cbb hanota problem \u6c49\u8bfa\u5854\u95ee\u9898 \u6cb3\u5167\u5854\u554f\u984c backtracking algorithm \u56de\u6eaf\u7b97\u6cd5 \u56de\u6eaf\u6f14\u7b97\u6cd5 constraint \u7ea6\u675f \u7d04\u675f solution \u89e3 \u89e3 state \u72b6\u6001 \u72c0\u614b pruning \u526a\u679d \u526a\u679d permutations problem \u5168\u6392\u5217\u95ee\u9898 \u5168\u6392\u5217\u554f\u984c subset-sum problem \u5b50\u96c6\u548c\u95ee\u9898 \u5b50\u96c6\u5408\u554f\u984c \\(n\\)-queens problem \\(n\\) \u7687\u540e\u95ee\u9898 \\(n\\) \u7687\u540e\u554f\u984c dynamic programming \u52a8\u6001\u89c4\u5212 \u52d5\u614b\u898f\u5283 initial state \u521d\u59cb\u72b6\u6001 \u521d\u59cb\u72c0\u614b state-transition equation \u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b \u72c0\u614b\u8f49\u79fb\u65b9\u7a0b knapsack problem \u80cc\u5305\u95ee\u9898 \u80cc\u5305\u554f\u984c edit distance problem \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898 \u7de8\u8f2f\u8ddd\u96e2\u554f\u984c greedy algorithm \u8d2a\u5fc3\u7b97\u6cd5 \u8caa\u5a6a\u6f14\u7b97\u6cd5"},{"location":"chapter_array_and_linkedlist/","title":"\u7b2c 4 \u7ae0 \u00a0 \u6570\u7ec4\u4e0e\u94fe\u8868","text":"

    Abstract

    \u6570\u636e\u7ed3\u6784\u7684\u4e16\u754c\u5982\u540c\u4e00\u5835\u539a\u5b9e\u7684\u7816\u5899\u3002

    \u6570\u7ec4\u7684\u7816\u5757\u6574\u9f50\u6392\u5217\uff0c\u9010\u4e2a\u7d27\u8d34\u3002\u94fe\u8868\u7684\u7816\u5757\u5206\u6563\u5404\u5904\uff0c\u8fde\u63a5\u7684\u85e4\u8513\u81ea\u7531\u5730\u7a7f\u68ad\u4e8e\u7816\u7f1d\u4e4b\u95f4\u3002

    "},{"location":"chapter_array_and_linkedlist/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 4.1 \u00a0 \u6570\u7ec4
    • 4.2 \u00a0 \u94fe\u8868
    • 4.3 \u00a0 \u5217\u8868
    • 4.4 \u00a0 \u5185\u5b58\u4e0e\u7f13\u5b58 *
    • 4.5 \u00a0 \u5c0f\u7ed3
    "},{"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\u7684\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\u8be5\u5143\u7d20\u7684\u300c\u7d22\u5f15 index\u300d\u3002\u56fe 4-1 \u5c55\u793a\u4e86\u6570\u7ec4\u7684\u4e3b\u8981\u6982\u5ff5\u548c\u5b58\u50a8\u65b9\u5f0f\u3002

    \u56fe 4-1 \u00a0 \u6570\u7ec4\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f

    "},{"location":"chapter_array_and_linkedlist/array/#411","title":"4.1.1 \u00a0 \u6570\u7ec4\u5e38\u7528\u64cd\u4f5c","text":""},{"location":"chapter_array_and_linkedlist/array/#1","title":"1. \u00a0 \u521d\u59cb\u5316\u6570\u7ec4","text":"

    \u6211\u4eec\u53ef\u4ee5\u6839\u636e\u9700\u6c42\u9009\u7528\u6570\u7ec4\u7684\u4e24\u79cd\u521d\u59cb\u5316\u65b9\u5f0f\uff1a\u65e0\u521d\u59cb\u503c\u3001\u7ed9\u5b9a\u521d\u59cb\u503c\u3002\u5728\u672a\u6307\u5b9a\u521d\u59cb\u503c\u7684\u60c5\u51b5\u4e0b\uff0c\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4f1a\u5c06\u6570\u7ec4\u5143\u7d20\u521d\u59cb\u5316\u4e3a \\(0\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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.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\uff08\u9700\u8981\u624b\u52a8\u91ca\u653e\u7a7a\u95f4\uff09\nint* arr1 = new int[5];\nint* nums1 = new int[5] { 1, 3, 2, 5, 4 };\n
    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.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.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.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.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.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
    array.rs
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nlet arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]\nlet nums: Vec<i32> = vec![1, 3, 2, 5, 4];\n
    array.c
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nint arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }\nint nums[5] = { 1, 3, 2, 5, 4 };\n
    array.kt
    /* \u521d\u59cb\u5316\u6570\u7ec4 */\nvar arr = IntArray(5) // { 0, 0, 0, 0, 0 }\nvar nums = intArrayOf(1, 3, 2, 5, 4)\n
    array.rb
    # \u521d\u59cb\u5316\u6570\u7ec4\narr = Array.new(5, 0)\nnums = [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
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#2","title":"2. \u00a0 \u8bbf\u95ee\u5143\u7d20","text":"

    \u6570\u7ec4\u5143\u7d20\u88ab\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u8fd9\u610f\u5473\u7740\u8ba1\u7b97\u6570\u7ec4\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\u975e\u5e38\u5bb9\u6613\u3002\u7ed9\u5b9a\u6570\u7ec4\u5185\u5b58\u5730\u5740\uff08\u9996\u5143\u7d20\u5185\u5b58\u5730\u5740\uff09\u548c\u67d0\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u56fe 4-2 \u6240\u793a\u7684\u516c\u5f0f\u8ba1\u7b97\u5f97\u5230\u8be5\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\uff0c\u4ece\u800c\u76f4\u63a5\u8bbf\u95ee\u8be5\u5143\u7d20\u3002

    \u56fe 4-2 \u00a0 \u6570\u7ec4\u5143\u7d20\u7684\u5185\u5b58\u5730\u5740\u8ba1\u7b97

    \u89c2\u5bdf\u56fe 4-2 \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\u4f46\u4ece\u5730\u5740\u8ba1\u7b97\u516c\u5f0f\u7684\u89d2\u5ea6\u770b\uff0c\u7d22\u5f15\u672c\u8d28\u4e0a\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\u5b83\u7684\u7d22\u5f15\u4e3a \\(0\\) \u662f\u5408\u7406\u7684\u3002

    \u5728\u6570\u7ec4\u4e2d\u8bbf\u95ee\u5143\u7d20\u975e\u5e38\u9ad8\u6548\uff0c\u6211\u4eec\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u968f\u673a\u8bbf\u95ee\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u4e00\u4e2a\u5143\u7d20\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    random_index = random.randint(0, len(nums) - 1)\n    # \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    random_num = nums[random_index]\n    return random_num\n
    array.cpp
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n    // \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = rand() % size;\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.java
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int[] nums) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.cs
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint RandomAccess(int[] nums) {\n    Random random = new();\n    // \u5728\u533a\u95f4 [0, nums.Length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = random.Next(nums.Length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.go
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunc randomAccess(nums []int) (randomNum int) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    randomIndex := rand.Intn(len(nums))\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    randomNum = nums[randomIndex]\n    return\n}\n
    array.swift
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunc randomAccess(nums: [Int]) -> Int {\n    // \u5728\u533a\u95f4 [0, nums.count) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    let randomIndex = nums.indices.randomElement()!\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    let randomNum = nums[randomIndex]\n    return randomNum\n}\n
    array.js
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunction randomAccess(nums) {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    const random_index = Math.floor(Math.random() * nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    const random_num = nums[random_index];\n    return random_num;\n}\n
    array.ts
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfunction randomAccess(nums: number[]): number {\n    // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    const random_index = Math.floor(Math.random() * nums.length);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    const random_num = nums[random_index];\n    return random_num;\n}\n
    array.dart
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(List<int> nums) {\n  // \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n  int randomIndex = Random().nextInt(nums.length);\n  // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n  int randomNum = nums[randomIndex];\n  return randomNum;\n}\n
    array.rs
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfn random_access(nums: &[i32]) -> i32 {\n    // \u5728\u533a\u95f4 [0, nums.len()) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    let random_index = rand::thread_rng().gen_range(0..nums.len());\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    let random_num = nums[random_index];\n    random_num\n}\n
    array.c
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nint randomAccess(int *nums, int size) {\n    // \u5728\u533a\u95f4 [0, size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    int randomIndex = rand() % size;\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    int randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    array.kt
    /* \u968f\u673a\u8bbf\u95ee\u5143\u7d20 */\nfun randomAccess(nums: IntArray): Int {\n    // \u5728\u533a\u95f4 [0, nums.size) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n    val randomIndex = ThreadLocalRandom.current().nextInt(0, nums.size)\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    val randomNum = nums[randomIndex]\n    return randomNum\n}\n
    array.rb
    ### \u968f\u673a\u8bbf\u95ee\u5143\u7d20 ###\ndef random_access(nums)\n  # \u5728\u533a\u95f4 [0, nums.length) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6570\u5b57\n  random_index = Random.rand 0...(nums.length - 1)\n\n  # \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n  nums[random_index]\nend\n
    array.zig
    // \u968f\u673a\u8bbf\u95ee\u5143\u7d20\nfn randomAccess(nums: []i32) i32 {\n    // \u5728\u533a\u95f4 [0, nums.len) \u4e2d\u968f\u673a\u62bd\u53d6\u4e00\u4e2a\u6574\u6570\n    var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);\n    // \u83b7\u53d6\u5e76\u8fd4\u56de\u968f\u673a\u5143\u7d20\n    var randomNum = nums[randomIndex];\n    return randomNum;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#3","title":"3. \u00a0 \u63d2\u5165\u5143\u7d20","text":"

    \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\u5b58\u653e\u4efb\u4f55\u6570\u636e\u3002\u5982\u56fe 4-3 \u6240\u793a\uff0c\u5982\u679c\u60f3\u5728\u6570\u7ec4\u4e2d\u95f4\u63d2\u5165\u4e00\u4e2a\u5143\u7d20\uff0c\u5219\u9700\u8981\u5c06\u8be5\u5143\u7d20\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u4e4b\u540e\u518d\u628a\u5143\u7d20\u8d4b\u503c\u7ed9\u8be5\u7d22\u5f15\u3002

    \u56fe 4-3 \u00a0 \u6570\u7ec4\u63d2\u5165\u5143\u7d20\u793a\u4f8b

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u7531\u4e8e\u6570\u7ec4\u7684\u957f\u5ea6\u662f\u56fa\u5b9a\u7684\uff0c\u56e0\u6b64\u63d2\u5165\u4e00\u4e2a\u5143\u7d20\u5fc5\u5b9a\u4f1a\u5bfc\u81f4\u6570\u7ec4\u5c3e\u90e8\u5143\u7d20\u201c\u4e22\u5931\u201d\u3002\u6211\u4eec\u5c06\u8fd9\u4e2a\u95ee\u9898\u7684\u89e3\u51b3\u65b9\u6848\u7559\u5728\u201c\u5217\u8868\u201d\u7ae0\u8282\u4e2d\u8ba8\u8bba\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def insert(nums: list[int], num: int, index: int):\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\n    for i in range(len(nums) - 1, index, -1):\n        nums[i] = nums[i - 1]\n    # \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num\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\n    for (int i = size - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    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\n    for (int i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (int i = nums.Length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\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\n    for i := len(nums) - 1; i > index; i-- {\n        nums[i] = nums[i-1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for i in nums.indices.dropFirst(index).reversed() {\n        nums[i] = nums[i - 1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (let i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (let i = nums.length - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 _num */\nvoid insert(List<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\n  for (var i = nums.length - 1; i > index; i--) {\n    nums[i] = nums[i - 1];\n  }\n  // \u5c06 _num \u8d4b\u7ed9 index \u5904\u5143\u7d20\n  nums[index] = _num;\n}\n
    array.rs
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfn insert(nums: &mut Vec<i32>, num: i32, index: usize) {\n    // \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for i in (index + 1..nums.len()).rev() {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[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\n    for (int i = size - 1; i > index; i--) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    array.kt
    /* \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num */\nfun insert(nums: IntArray, num: Int, index: Int) {\n    // \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for (i in nums.size - 1 downTo index + 1) {\n        nums[i] = nums[i - 1]\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num\n}\n
    array.rb
    ### \u5728\u6570\u7ec4\u7684\u7d22\u5f15 index \u5904\u63d2\u5165\u5143\u7d20 num ###\ndef insert(nums, num, index)\n  # \u628a\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n  for i in (nums.length - 1).downto(index + 1)\n    nums[i] = nums[i - 1]\n  end\n\n  # \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n  nums[index] = num\nend\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\n    var i = nums.len - 1;\n    while (i > index) : (i -= 1) {\n        nums[i] = nums[i - 1];\n    }\n    // \u5c06 num \u8d4b\u7ed9 index \u5904\u7684\u5143\u7d20\n    nums[index] = num;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#4","title":"4. \u00a0 \u5220\u9664\u5143\u7d20","text":"

    \u540c\u7406\uff0c\u5982\u56fe 4-4 \u6240\u793a\uff0c\u82e5\u60f3\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

    \u56fe 4-4 \u00a0 \u6570\u7ec4\u5220\u9664\u5143\u7d20\u793a\u4f8b

    \u8bf7\u6ce8\u610f\uff0c\u5220\u9664\u5143\u7d20\u5b8c\u6210\u540e\uff0c\u539f\u5148\u672b\u5c3e\u7684\u5143\u7d20\u53d8\u5f97\u201c\u65e0\u610f\u4e49\u201d\u4e86\uff0c\u6240\u4ee5\u6211\u4eec\u65e0\u987b\u7279\u610f\u53bb\u4fee\u6539\u5b83\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def remove(nums: list[int], index: int):\n    \"\"\"\u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20\"\"\"\n    # \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in range(index, len(nums) - 1):\n        nums[i] = nums[i + 1]\n
    array.cpp
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.java
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.cs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < nums.Length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.go
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for i := index; i < len(nums)-1; i++ {\n        nums[i] = nums[i+1]\n    }\n}\n
    array.swift
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfunc remove(nums: inout [Int], index: Int) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in nums.indices.dropFirst(index).dropLast() {\n        nums[i] = nums[i + 1]\n    }\n}\n
    array.js
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfunction remove(nums, index) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (let i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.ts
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (let i = index; i < nums.length - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.dart
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nvoid remove(List<int> nums, int index) {\n  // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n  for (var i = index; i < nums.length - 1; i++) {\n    nums[i] = nums[i + 1];\n  }\n}\n
    array.rs
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfn remove(nums: &mut Vec<i32>, index: usize) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for i in index..nums.len() - 1 {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.c
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    for (int i = index; i < size - 1; i++) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    array.kt
    /* \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 */\nfun remove(nums: IntArray, index: Int) {\n    // \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (i in index..<nums.size - 1) {\n        nums[i] = nums[i + 1]\n    }\n}\n
    array.rb
    ### \u5220\u9664\u7d22\u5f15 index \u5904\u7684\u5143\u7d20 ###\ndef remove(nums, index)\n  # \u628a\u7d22\u5f15 index \u4e4b\u540e\u7684\u6240\u6709\u5143\u7d20\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n  for i in index...nums.length\n    nums[i] = nums[i + 1] || 0\n  end\nend\n
    array.zig
    // \u5220\u9664\u7d22\u5f15 index \u5904\u7684\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\n    var i = index;\n    while (i < nums.len - 1) : (i += 1) {\n        nums[i] = nums[i + 1];\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

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

    • \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\u201c\u65e0\u610f\u4e49\u201d\u7684\uff0c\u4f46\u8fd9\u6837\u505a\u4f1a\u9020\u6210\u90e8\u5206\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u3002
    "},{"location":"chapter_array_and_linkedlist/array/#5","title":"5. \u00a0 \u904d\u5386\u6570\u7ec4","text":"

    \u5728\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u6211\u4eec\u65e2\u53ef\u4ee5\u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\uff0c\u4e5f\u53ef\u4ee5\u76f4\u63a5\u904d\u5386\u83b7\u53d6\u6570\u7ec4\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def traverse(nums: list[int]):\n    \"\"\"\u904d\u5386\u6570\u7ec4\"\"\"\n    count = 0\n    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in range(len(nums)):\n        count += nums[i]\n    # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums:\n        count += num\n    # \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for i, num in enumerate(nums):\n        count += nums[i]\n        count += num\n
    array.cpp
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        count += nums[i];\n    }\n}\n
    array.java
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int[] nums) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (int num : nums) {\n        count += num;\n    }\n}\n
    array.cs
    /* \u904d\u5386\u6570\u7ec4 */\nvoid Traverse(int[] nums) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < nums.Length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    foreach (int num in nums) {\n        count += num;\n    }\n}\n
    array.go
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums []int) {\n    count := 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i := 0; i < len(nums); i++ {\n        count += nums[i]\n    }\n    count = 0\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for _, num := range nums {\n        count += num\n    }\n    // \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for i, num := range nums {\n        count += nums[i]\n        count += num\n    }\n}\n
    array.swift
    /* \u904d\u5386\u6570\u7ec4 */\nfunc traverse(nums: [Int]) {\n    var count = 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in nums.indices {\n        count += nums[i]\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums {\n        count += num\n    }\n    // \u540c\u65f6\u904d\u5386\u6570\u636e\u7d22\u5f15\u548c\u5143\u7d20\n    for (i, num) in nums.enumerated() {\n        count += nums[i]\n        count += num\n    }\n}\n
    array.js
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums) {\n    let count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (let i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (const num of nums) {\n        count += num;\n    }\n}\n
    array.ts
    /* \u904d\u5386\u6570\u7ec4 */\nfunction traverse(nums: number[]): void {\n    let count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (let i = 0; i < nums.length; i++) {\n        count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (const num of nums) {\n        count += num;\n    }\n}\n
    array.dart
    /* \u904d\u5386\u6570\u7ec4\u5143\u7d20 */\nvoid traverse(List<int> nums) {\n  int count = 0;\n  // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n  for (var i = 0; i < nums.length; i++) {\n    count += nums[i];\n  }\n  // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n  for (int _num in nums) {\n    count += _num;\n  }\n  // \u901a\u8fc7 forEach \u65b9\u6cd5\u904d\u5386\u6570\u7ec4\n  nums.forEach((_num) {\n    count += _num;\n  });\n}\n
    array.rs
    /* \u904d\u5386\u6570\u7ec4 */\nfn traverse(nums: &[i32]) {\n    let mut _count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for i in 0..nums.len() {\n        _count += nums[i];\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for num in nums {\n        _count += num;\n    }\n}\n
    array.c
    /* \u904d\u5386\u6570\u7ec4 */\nvoid traverse(int *nums, int size) {\n    int count = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        count += nums[i];\n    }\n}\n
    array.kt
    /* \u904d\u5386\u6570\u7ec4 */\nfun traverse(nums: IntArray) {\n    var count = 0\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    for (i in nums.indices) {\n        count += nums[i]\n    }\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (j: Int in nums) {\n        count += j\n    }\n}\n
    array.rb
    ### \u904d\u5386\u6570\u7ec4 ###\ndef traverse(nums)\n  count = 0\n\n  # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n  for i in 0...nums.length\n    count += nums[i]\n  end\n\n  # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n  for num in nums\n    count += num\n  end\nend\n
    array.zig
    // \u904d\u5386\u6570\u7ec4\nfn traverse(nums: []i32) void {\n    var count: i32 = 0;\n    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u6570\u7ec4\n    var i: i32 = 0;\n    while (i < nums.len) : (i += 1) {\n        count += nums[i];\n    }\n    count = 0;\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\u5143\u7d20\n    for (nums) |num| {\n        count += num;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#6","title":"6. \u00a0 \u67e5\u627e\u5143\u7d20","text":"

    \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\u9700\u8981\u904d\u5386\u6570\u7ec4\uff0c\u6bcf\u8f6e\u5224\u65ad\u5143\u7d20\u503c\u662f\u5426\u5339\u914d\uff0c\u82e5\u5339\u914d\u5219\u8f93\u51fa\u5bf9\u5e94\u7d22\u5f15\u3002

    \u56e0\u4e3a\u6570\u7ec4\u662f\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u6240\u4ee5\u4e0a\u8ff0\u67e5\u627e\u64cd\u4f5c\u88ab\u79f0\u4e3a\u201c\u7ebf\u6027\u67e5\u627e\u201d\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array.py
    def find(nums: list[int], target: int) -> int:\n    \"\"\"\u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\"\"\"\n    for i in range(len(nums)):\n        if nums[i] == target:\n            return i\n    return -1\n
    array.cpp
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i < size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.java
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int[] nums, int target) {\n    for (int i = 0; i < nums.length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.cs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint Find(int[] nums, int target) {\n    for (int i = 0; i < nums.Length; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.go
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums []int, target int) (index int) {\n    index = -1\n    for i := 0; i < len(nums); i++ {\n        if nums[i] == target {\n            index = i\n            break\n        }\n    }\n    return\n}\n
    array.swift
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunc find(nums: [Int], target: Int) -> Int {\n    for i in nums.indices {\n        if nums[i] == target {\n            return i\n        }\n    }\n    return -1\n}\n
    array.js
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums, target) {\n    for (let i = 0; i < nums.length; i++) {\n        if (nums[i] === target) return i;\n    }\n    return -1;\n}\n
    array.ts
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfunction find(nums: number[], target: number): number {\n    for (let i = 0; i < nums.length; i++) {\n        if (nums[i] === target) {\n            return i;\n        }\n    }\n    return -1;\n}\n
    array.dart
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(List<int> nums, int target) {\n  for (var i = 0; i < nums.length; i++) {\n    if (nums[i] == target) return i;\n  }\n  return -1;\n}\n
    array.rs
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfn find(nums: &[i32], target: i32) -> Option<usize> {\n    for i in 0..nums.len() {\n        if nums[i] == target {\n            return Some(i);\n        }\n    }\n    None\n}\n
    array.c
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nint find(int *nums, int size, int target) {\n    for (int i = 0; i < size; i++) {\n        if (nums[i] == target)\n            return i;\n    }\n    return -1;\n}\n
    array.kt
    /* \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 */\nfun find(nums: IntArray, target: Int): Int {\n    for (i in nums.indices) {\n        if (nums[i] == target) return i\n    }\n    return -1\n}\n
    array.rb
    ### \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20 ###\ndef find(nums, target)\n  for i in 0...nums.length\n    return i if nums[i] == target\n  end\n\n  -1\nend\n
    array.zig
    // \u5728\u6570\u7ec4\u4e2d\u67e5\u627e\u6307\u5b9a\u5143\u7d20\nfn find(nums: []i32, target: i32) i32 {\n    for (nums, 0..) |num, i| {\n        if (num == target) return @intCast(i);\n    }\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#7","title":"7. \u00a0 \u6269\u5bb9\u6570\u7ec4","text":"

    \u5728\u590d\u6742\u7684\u7cfb\u7edf\u73af\u5883\u4e2d\uff0c\u7a0b\u5e8f\u96be\u4ee5\u4fdd\u8bc1\u6570\u7ec4\u4e4b\u540e\u7684\u5185\u5b58\u7a7a\u95f4\u662f\u53ef\u7528\u7684\uff0c\u4ece\u800c\u65e0\u6cd5\u5b89\u5168\u5730\u6269\u5c55\u6570\u7ec4\u5bb9\u91cf\u3002\u56e0\u6b64\u5728\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u6570\u7ec4\u7684\u957f\u5ea6\u662f\u4e0d\u53ef\u53d8\u7684\u3002

    \u5982\u679c\u6211\u4eec\u5e0c\u671b\u6269\u5bb9\u6570\u7ec4\uff0c\u5219\u9700\u91cd\u65b0\u5efa\u7acb\u4e00\u4e2a\u66f4\u5927\u7684\u6570\u7ec4\uff0c\u7136\u540e\u628a\u539f\u6570\u7ec4\u5143\u7d20\u4f9d\u6b21\u590d\u5236\u5230\u65b0\u6570\u7ec4\u3002\u8fd9\u662f\u4e00\u4e2a \\(O(n)\\) \u7684\u64cd\u4f5c\uff0c\u5728\u6570\u7ec4\u5f88\u5927\u7684\u60c5\u51b5\u4e0b\u975e\u5e38\u8017\u65f6\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    res = [0] * (len(nums) + enlarge)\n    # \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for i in range(len(nums)):\n        res[i] = nums[i]\n    # \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res\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\n    int *res = new int[size + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        res[i] = nums[i];\n    }\n    // \u91ca\u653e\u5185\u5b58\n    delete[] nums;\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    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\n    int[] res = new int[nums.length + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\n    int[] res = new int[nums.Length + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < nums.Length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\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\n    res := make([]int, len(nums)+enlarge)\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for i, num := range nums {\n        res[i] = num\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\n    var 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\n    for i in nums.indices {\n        res[i] = nums[i]\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\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\n    const 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\n    for (let i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return 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\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\n    const 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\n    for (let i = 0; i < nums.length; i++) {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    array.dart
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nList<int> extend(List<int> nums, int enlarge) {\n  // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n  List<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\n  for (var i = 0; i < nums.length; i++) {\n    res[i] = nums[i];\n  }\n  // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n  return res;\n}\n
    array.rs
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfn extend(nums: Vec<i32>, enlarge: usize) -> Vec<i32> {\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n    let mut res: Vec<i32> = vec![0; nums.len() + enlarge];\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\n    for i in 0..nums.len() {\n        res[i] = nums[i];\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    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\n    int *res = (int *)malloc(sizeof(int) * (size + enlarge));\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (int i = 0; i < size; i++) {\n        res[i] = nums[i];\n    }\n    // \u521d\u59cb\u5316\u6269\u5c55\u540e\u7684\u7a7a\u95f4\n    for (int i = size; i < size + enlarge; i++) {\n        res[i] = 0;\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    array.kt
    /* \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 */\nfun extend(nums: IntArray, enlarge: Int): IntArray {\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n    val res = IntArray(nums.size + enlarge)\n    // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    for (i in nums.indices) {\n        res[i] = nums[i]\n    }\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res\n}\n
    array.rb
    ### \u6269\u5c55\u6570\u7ec4\u957f\u5ea6 ###\n# \u8bf7\u6ce8\u610f\uff0cRuby \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\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6570\u7ec4\ndef extend(nums, enlarge)\n  # \u521d\u59cb\u5316\u4e00\u4e2a\u6269\u5c55\u957f\u5ea6\u540e\u7684\u6570\u7ec4\n  res = Array.new(nums.length + enlarge, 0)\n\n  # \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n  for i in 0...nums.length\n    res[i] = nums[i]\n  end\n\n  # \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n  res\nend\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\n    var 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\n    std.mem.copy(i32, res, nums);\n    // \u8fd4\u56de\u6269\u5c55\u540e\u7684\u65b0\u6570\u7ec4\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/array/#412","title":"4.1.2 \u00a0 \u6570\u7ec4\u7684\u4f18\u70b9\u4e0e\u5c40\u9650\u6027","text":"

    \u6570\u7ec4\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u5185\uff0c\u4e14\u5143\u7d20\u7c7b\u578b\u76f8\u540c\u3002\u8fd9\u79cd\u505a\u6cd5\u5305\u542b\u4e30\u5bcc\u7684\u5148\u9a8c\u4fe1\u606f\uff0c\u7cfb\u7edf\u53ef\u4ee5\u5229\u7528\u8fd9\u4e9b\u4fe1\u606f\u6765\u4f18\u5316\u6570\u636e\u7ed3\u6784\u7684\u64cd\u4f5c\u6548\u7387\u3002

    • \u7a7a\u95f4\u6548\u7387\u9ad8\uff1a\u6570\u7ec4\u4e3a\u6570\u636e\u5206\u914d\u4e86\u8fde\u7eed\u7684\u5185\u5b58\u5757\uff0c\u65e0\u987b\u989d\u5916\u7684\u7ed3\u6784\u5f00\u9500\u3002
    • \u652f\u6301\u968f\u673a\u8bbf\u95ee\uff1a\u6570\u7ec4\u5141\u8bb8\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u8bbf\u95ee\u4efb\u4f55\u5143\u7d20\u3002
    • \u7f13\u5b58\u5c40\u90e8\u6027\uff1a\u5f53\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

    \u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u662f\u4e00\u628a\u53cc\u5203\u5251\uff0c\u5176\u5b58\u5728\u4ee5\u4e0b\u5c40\u9650\u6027\u3002

    • \u63d2\u5165\u4e0e\u5220\u9664\u6548\u7387\u4f4e\uff1a\u5f53\u6570\u7ec4\u4e2d\u5143\u7d20\u8f83\u591a\u65f6\uff0c\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u9700\u8981\u79fb\u52a8\u5927\u91cf\u7684\u5143\u7d20\u3002
    • \u957f\u5ea6\u4e0d\u53ef\u53d8\uff1a\u6570\u7ec4\u5728\u521d\u59cb\u5316\u540e\u957f\u5ea6\u5c31\u56fa\u5b9a\u4e86\uff0c\u6269\u5bb9\u6570\u7ec4\u9700\u8981\u5c06\u6240\u6709\u6570\u636e\u590d\u5236\u5230\u65b0\u6570\u7ec4\uff0c\u5f00\u9500\u5f88\u5927\u3002
    • \u7a7a\u95f4\u6d6a\u8d39\uff1a\u5982\u679c\u6570\u7ec4\u5206\u914d\u7684\u5927\u5c0f\u8d85\u8fc7\u5b9e\u9645\u6240\u9700\uff0c\u90a3\u4e48\u591a\u4f59\u7684\u7a7a\u95f4\u5c31\u88ab\u6d6a\u8d39\u4e86\u3002
    "},{"location":"chapter_array_and_linkedlist/array/#413","title":"4.1.3 \u00a0 \u6570\u7ec4\u5178\u578b\u5e94\u7528","text":"

    \u6570\u7ec4\u662f\u4e00\u79cd\u57fa\u7840\u4e14\u5e38\u89c1\u7684\u6570\u636e\u7ed3\u6784\uff0c\u65e2\u9891\u7e41\u5e94\u7528\u5728\u5404\u7c7b\u7b97\u6cd5\u4e4b\u4e2d\uff0c\u4e5f\u53ef\u7528\u4e8e\u5b9e\u73b0\u5404\u79cd\u590d\u6742\u6570\u636e\u7ed3\u6784\u3002

    • \u968f\u673a\u8bbf\u95ee\uff1a\u5982\u679c\u6211\u4eec\u60f3\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\u968f\u673a\u62bd\u6837\u3002
    • \u6392\u5e8f\u548c\u641c\u7d22\uff1a\u6570\u7ec4\u662f\u6392\u5e8f\u548c\u641c\u7d22\u7b97\u6cd5\u6700\u5e38\u7528\u7684\u6570\u636e\u7ed3\u6784\u3002\u5feb\u901f\u6392\u5e8f\u3001\u5f52\u5e76\u6392\u5e8f\u3001\u4e8c\u5206\u67e5\u627e\u7b49\u90fd\u4e3b\u8981\u5728\u6570\u7ec4\u4e0a\u8fdb\u884c\u3002
    • \u67e5\u627e\u8868\uff1a\u5f53\u9700\u8981\u5feb\u901f\u67e5\u627e\u4e00\u4e2a\u5143\u7d20\u6216\u5176\u5bf9\u5e94\u5173\u7cfb\u65f6\uff0c\u53ef\u4ee5\u4f7f\u7528\u6570\u7ec4\u4f5c\u4e3a\u67e5\u627e\u8868\u3002\u5047\u5982\u6211\u4eec\u60f3\u5b9e\u73b0\u5b57\u7b26\u5230 ASCII \u7801\u7684\u6620\u5c04\uff0c\u5219\u53ef\u4ee5\u5c06\u5b57\u7b26\u7684 ASCII \u7801\u503c\u4f5c\u4e3a\u7d22\u5f15\uff0c\u5bf9\u5e94\u7684\u5143\u7d20\u5b58\u653e\u5728\u6570\u7ec4\u4e2d\u7684\u5bf9\u5e94\u4f4d\u7f6e\u3002
    • \u673a\u5668\u5b66\u4e60\uff1a\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
    • \u6570\u636e\u7ed3\u6784\u5b9e\u73b0\uff1a\u6570\u7ec4\u53ef\u4ee5\u7528\u4e8e\u5b9e\u73b0\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u5806\u3001\u56fe\u7b49\u6570\u636e\u7ed3\u6784\u3002\u4f8b\u5982\uff0c\u56fe\u7684\u90bb\u63a5\u77e9\u9635\u8868\u793a\u5b9e\u9645\u4e0a\u662f\u4e00\u4e2a\u4e8c\u7ef4\u6570\u7ec4\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\u5728\u4e00\u4e2a\u590d\u6742\u7684\u7cfb\u7edf\u8fd0\u884c\u73af\u5883\u4e0b\uff0c\u7a7a\u95f2\u7684\u5185\u5b58\u7a7a\u95f4\u53ef\u80fd\u6563\u843d\u5728\u5185\u5b58\u5404\u5904\u3002\u6211\u4eec\u77e5\u9053\uff0c\u5b58\u50a8\u6570\u7ec4\u7684\u5185\u5b58\u7a7a\u95f4\u5fc5\u987b\u662f\u8fde\u7eed\u7684\uff0c\u800c\u5f53\u6570\u7ec4\u975e\u5e38\u5927\u65f6\uff0c\u5185\u5b58\u53ef\u80fd\u65e0\u6cd5\u63d0\u4f9b\u5982\u6b64\u5927\u7684\u8fde\u7eed\u7a7a\u95f4\u3002\u6b64\u65f6\u94fe\u8868\u7684\u7075\u6d3b\u6027\u4f18\u52bf\u5c31\u4f53\u73b0\u51fa\u6765\u4e86\u3002

    \u300c\u94fe\u8868 linked list\u300d\u662f\u4e00\u79cd\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff0c\u5176\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\u90fd\u662f\u4e00\u4e2a\u8282\u70b9\u5bf9\u8c61\uff0c\u5404\u4e2a\u8282\u70b9\u901a\u8fc7\u201c\u5f15\u7528\u201d\u76f8\u8fde\u63a5\u3002\u5f15\u7528\u8bb0\u5f55\u4e86\u4e0b\u4e00\u4e2a\u8282\u70b9\u7684\u5185\u5b58\u5730\u5740\uff0c\u901a\u8fc7\u5b83\u53ef\u4ee5\u4ece\u5f53\u524d\u8282\u70b9\u8bbf\u95ee\u5230\u4e0b\u4e00\u4e2a\u8282\u70b9\u3002

    \u94fe\u8868\u7684\u8bbe\u8ba1\u4f7f\u5f97\u5404\u4e2a\u8282\u70b9\u53ef\u4ee5\u5206\u6563\u5b58\u50a8\u5728\u5185\u5b58\u5404\u5904\uff0c\u5b83\u4eec\u7684\u5185\u5b58\u5730\u5740\u65e0\u987b\u8fde\u7eed\u3002

    \u56fe 4-5 \u00a0 \u94fe\u8868\u5b9a\u4e49\u4e0e\u5b58\u50a8\u65b9\u5f0f

    \u89c2\u5bdf\u56fe 4-5 \uff0c\u94fe\u8868\u7684\u7ec4\u6210\u5355\u4f4d\u662f\u300c\u8282\u70b9 node\u300d\u5bf9\u8c61\u3002\u6bcf\u4e2a\u8282\u70b9\u90fd\u5305\u542b\u4e24\u9879\u6570\u636e\uff1a\u8282\u70b9\u7684\u201c\u503c\u201d\u548c\u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u201c\u5f15\u7528\u201d\u3002

    • \u94fe\u8868\u7684\u9996\u4e2a\u8282\u70b9\u88ab\u79f0\u4e3a\u201c\u5934\u8282\u70b9\u201d\uff0c\u6700\u540e\u4e00\u4e2a\u8282\u70b9\u88ab\u79f0\u4e3a\u201c\u5c3e\u8282\u70b9\u201d\u3002
    • \u5c3e\u8282\u70b9\u6307\u5411\u7684\u662f\u201c\u7a7a\u201d\uff0c\u5b83\u5728 Java\u3001C++ \u548c Python \u4e2d\u5206\u522b\u88ab\u8bb0\u4e3a null\u3001nullptr \u548c None \u3002
    • \u5728 C\u3001C++\u3001Go \u548c Rust \u7b49\u652f\u6301\u6307\u9488\u7684\u8bed\u8a00\u4e2d\uff0c\u4e0a\u8ff0\u201c\u5f15\u7528\u201d\u5e94\u88ab\u66ff\u6362\u4e3a\u201c\u6307\u9488\u201d\u3002

    \u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u94fe\u8868\u8282\u70b9 ListNode \u9664\u4e86\u5305\u542b\u503c\uff0c\u8fd8\u9700\u989d\u5916\u4fdd\u5b58\u4e00\u4e2a\u5f15\u7528\uff08\u6307\u9488\uff09\u3002\u56e0\u6b64\u5728\u76f8\u540c\u6570\u636e\u91cf\u4e0b\uff0c\u94fe\u8868\u6bd4\u6570\u7ec4\u5360\u7528\u66f4\u591a\u7684\u5185\u5b58\u7a7a\u95f4\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class ListNode:\n    \"\"\"\u94fe\u8868\u8282\u70b9\u7c7b\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val               # \u8282\u70b9\u503c\n        self.next: ListNode | None = None # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\n    int val;         // \u8282\u70b9\u503c\n    ListNode *next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n    ListNode(int x) : val(x), next(nullptr) {}  // \u6784\u9020\u51fd\u6570\n};\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    int val;        // \u8282\u70b9\u503c\n    ListNode next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    ListNode(int x) { val = x; }  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode(int x) {  //\u6784\u9020\u51fd\u6570\n    int val = x;         // \u8282\u70b9\u503c\n    ListNode? next;      // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype ListNode struct {\n    Val  int       // \u8282\u70b9\u503c\n    Next *ListNode // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n}\n\n// NewListNode \u6784\u9020\u51fd\u6570\uff0c\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u94fe\u8868\nfunc NewListNode(val int) *ListNode {\n    return &ListNode{\n        Val:  val,\n        Next: nil,\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    var val: Int // \u8282\u70b9\u503c\n    var next: ListNode? // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n\n    init(x: Int) { // \u6784\u9020\u51fd\u6570\n        val = x\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    constructor(val, next) {\n        this.val = (val === undefined ? 0 : val);       // \u8282\u70b9\u503c\n        this.next = (next === undefined ? null : next); // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    constructor(val?: number, next?: ListNode | null) {\n        this.val = val === undefined ? 0 : val;        // \u8282\u70b9\u503c\n        this.next = next === undefined ? null : next;  // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n  int val; // \u8282\u70b9\u503c\n  ListNode? next; // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n  ListNode(this.val, [this.next]); // \u6784\u9020\u51fd\u6570\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n/* \u94fe\u8868\u8282\u70b9\u7c7b */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // \u8282\u70b9\u503c\n    next: Option<Rc<RefCell<ListNode>>>, // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct ListNode {\n    int val;               // \u8282\u70b9\u503c\n    struct ListNode *next; // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n} ListNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node->val = val;\n    node->next = NULL;\n    return node;\n}\n
    /* \u94fe\u8868\u8282\u70b9\u7c7b */\n// \u6784\u9020\u65b9\u6cd5\nclass ListNode(x: Int) {\n    val _val: Int = x          // \u8282\u70b9\u503c\n    val next: ListNode? = null // \u6307\u5411\u4e0b\u4e00\u4e2a\u8282\u70b9\u7684\u5f15\u7528\n}\n
    # \u94fe\u8868\u8282\u70b9\u7c7b\nclass ListNode\n  attr_accessor :val  # \u8282\u70b9\u503c\n  attr_accessor :next # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n\n  def initialize(val=0, next_node=nil)\n    @val = val\n    @next = next_node\n  end\nend\n
    // \u94fe\u8868\u8282\u70b9\u7c7b\npub fn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = 0, // \u8282\u70b9\u503c\n        next: ?*Self = null, // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u6307\u9488\n\n        // \u6784\u9020\u51fd\u6570\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n        }\n    };\n}\n
    "},{"location":"chapter_array_and_linkedlist/linked_list/#421","title":"4.2.1 \u00a0 \u94fe\u8868\u5e38\u7528\u64cd\u4f5c","text":""},{"location":"chapter_array_and_linkedlist/linked_list/#1","title":"1. \u00a0 \u521d\u59cb\u5316\u94fe\u8868","text":"

    \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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\u5173\u7cfb\u3002\u521d\u59cb\u5316\u5b8c\u6210\u540e\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u4ece\u94fe\u8868\u7684\u5934\u8282\u70b9\u51fa\u53d1\uff0c\u901a\u8fc7\u5f15\u7528\u6307\u5411 next \u4f9d\u6b21\u8bbf\u95ee\u6240\u6709\u8282\u70b9\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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(1);\nListNode n1 = new(3);\nListNode n2 = new(2);\nListNode n3 = new(5);\nListNode n4 = new(4);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.rs
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nlet n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));\nlet n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));\nlet n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));\nlet n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));\nlet n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));\n\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0.borrow_mut().next = Some(n1.clone());\nn1.borrow_mut().next = Some(n2.clone());\nn2.borrow_mut().next = Some(n3.clone());\nn3.borrow_mut().next = Some(n4.clone());\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0->next = n1;\nn1->next = n2;\nn2->next = n3;\nn3->next = n4;\n
    linked_list.kt
    /* \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4 */\n// \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nval n0 = ListNode(1)\nval n1 = ListNode(3)\nval n2 = ListNode(2)\nval n3 = ListNode(5)\nval n4 = ListNode(4)\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0.next = n1;\nn1.next = n2;\nn2.next = n3;\nn3.next = n4;\n
    linked_list.rb
    # \u521d\u59cb\u5316\u94fe\u8868 1 -> 3 -> 2 -> 5 -> 4\n# \u521d\u59cb\u5316\u5404\u4e2a\u8282\u70b9\nn0 = ListNode.new 1\nn1 = ListNode.new 3\nn2 = ListNode.new 2\nn3 = ListNode.new 5\nn4 = ListNode.new 4\n# \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\nn0.next = &n1;\nn1.next = &n2;\nn2.next = &n3;\nn3.next = &n4;\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6570\u7ec4\u6574\u4f53\u662f\u4e00\u4e2a\u53d8\u91cf\uff0c\u6bd4\u5982\u6570\u7ec4 nums \u5305\u542b\u5143\u7d20 nums[0] \u548c nums[1] \u7b49\uff0c\u800c\u94fe\u8868\u662f\u7531\u591a\u4e2a\u72ec\u7acb\u7684\u8282\u70b9\u5bf9\u8c61\u7ec4\u6210\u7684\u3002\u6211\u4eec\u901a\u5e38\u5c06\u5934\u8282\u70b9\u5f53\u4f5c\u94fe\u8868\u7684\u4ee3\u79f0\uff0c\u6bd4\u5982\u4ee5\u4e0a\u4ee3\u7801\u4e2d\u7684\u94fe\u8868\u53ef\u8bb0\u4f5c\u94fe\u8868 n0 \u3002

    "},{"location":"chapter_array_and_linkedlist/linked_list/#2","title":"2. \u00a0 \u63d2\u5165\u8282\u70b9","text":"

    \u5728\u94fe\u8868\u4e2d\u63d2\u5165\u8282\u70b9\u975e\u5e38\u5bb9\u6613\u3002\u5982\u56fe 4-6 \u6240\u793a\uff0c\u5047\u8bbe\u6211\u4eec\u60f3\u5728\u76f8\u90bb\u7684\u4e24\u4e2a\u8282\u70b9 n0 \u548c n1 \u4e4b\u95f4\u63d2\u5165\u4e00\u4e2a\u65b0\u8282\u70b9 P \uff0c\u5219\u53ea\u9700\u6539\u53d8\u4e24\u4e2a\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\u5373\u53ef\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002

    \u76f8\u6bd4\u4e4b\u4e0b\uff0c\u5728\u6570\u7ec4\u4e2d\u63d2\u5165\u5143\u7d20\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5728\u5927\u6570\u636e\u91cf\u4e0b\u7684\u6548\u7387\u8f83\u4f4e\u3002

    \u56fe 4-6 \u00a0 \u94fe\u8868\u63d2\u5165\u8282\u70b9\u793a\u4f8b

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def insert(n0: ListNode, P: ListNode):\n    \"\"\"\u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P\"\"\"\n    n1 = n0.next\n    P.next = n1\n    n0.next = P\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode *n0, ListNode *P) {\n    ListNode *n1 = n0->next;\n    P->next = n1;\n    n0->next = P;\n}\n
    linked_list.java
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nvoid insert(ListNode n0, ListNode P) {\n    ListNode n1 = n0.next;\n    P.next = n1;\n    n0.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) {\n    ListNode? n1 = n0.next;\n    P.next = n1;\n    n0.next = P;\n}\n
    linked_list.go
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\nfunc insertNode(n0 *ListNode, P *ListNode) {\n    n1 := n0.Next\n    P.Next = n1\n    n0.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) {\n    let n1 = n0.next\n    P.next = n1\n    n0.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) {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.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 {\n    const n1 = n0.next;\n    P.next = n1;\n    n0.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) {\n  ListNode? n1 = n0.next;\n  P.next = n1;\n  n0.next = P;\n}\n
    linked_list.rs
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 P */\n#[allow(non_snake_case)]\npub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {\n    let n1 = n0.borrow_mut().next.take();\n    P.borrow_mut().next = n1;\n    n0.borrow_mut().next = Some(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) {\n    ListNode *n1 = n0->next;\n    P->next = n1;\n    n0->next = P;\n}\n
    linked_list.kt
    /* \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9p */\nfun insert(n0: ListNode?, p: ListNode?) {\n    val n1 = n0?.next\n    p?.next = n1\n    n0?.next = p\n}\n
    linked_list.rb
    ### \u5728\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u63d2\u5165\u8282\u70b9 _p ###\n# Ruby \u7684 `p` \u662f\u4e00\u4e2a\u5185\u7f6e\u51fd\u6570\uff0c `P` \u662f\u4e00\u4e2a\u5e38\u91cf\uff0c\u6240\u4ee5\u53ef\u4ee5\u4f7f\u7528 `_p` \u4ee3\u66ff\ndef insert(n0, _p)\n  n1 = n0.next\n  _p.next = n1\n  n0.next = _p\nend\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 {\n    var n1 = n0.?.next;\n    P.?.next = n1;\n    n0.?.next = P;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#3","title":"3. \u00a0 \u5220\u9664\u8282\u70b9","text":"

    \u5982\u56fe 4-7 \u6240\u793a\uff0c\u5728\u94fe\u8868\u4e2d\u5220\u9664\u8282\u70b9\u4e5f\u975e\u5e38\u65b9\u4fbf\uff0c\u53ea\u9700\u6539\u53d8\u4e00\u4e2a\u8282\u70b9\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\u5373\u53ef\u3002

    \u8bf7\u6ce8\u610f\uff0c\u5c3d\u7ba1\u5728\u5220\u9664\u64cd\u4f5c\u5b8c\u6210\u540e\u8282\u70b9 P \u4ecd\u7136\u6307\u5411 n1 \uff0c\u4f46\u5b9e\u9645\u4e0a\u904d\u5386\u6b64\u94fe\u8868\u5df2\u7ecf\u65e0\u6cd5\u8bbf\u95ee\u5230 P \uff0c\u8fd9\u610f\u5473\u7740 P \u5df2\u7ecf\u4e0d\u518d\u5c5e\u4e8e\u8be5\u94fe\u8868\u4e86\u3002

    \u56fe 4-7 \u00a0 \u94fe\u8868\u5220\u9664\u8282\u70b9

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def remove(n0: ListNode):\n    \"\"\"\u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9\"\"\"\n    if not n0.next:\n        return\n    # n0 -> P -> n1\n    P = n0.next\n    n1 = P.next\n    n0.next = n1\n
    linked_list.cpp
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode *n0) {\n    if (n0->next == nullptr)\n        return;\n    // n0 -> P -> n1\n    ListNode *P = n0->next;\n    ListNode *n1 = P->next;\n    n0->next = n1;\n    // \u91ca\u653e\u5185\u5b58\n    delete P;\n}\n
    linked_list.java
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -> P -> n1\n    ListNode P = n0.next;\n    ListNode n1 = P.next;\n    n0.next = n1;\n}\n
    linked_list.cs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nvoid Remove(ListNode n0) {\n    if (n0.next == null)\n        return;\n    // n0 -> P -> n1\n    ListNode P = n0.next;\n    ListNode? n1 = P.next;\n    n0.next = n1;\n}\n
    linked_list.go
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfunc removeItem(n0 *ListNode) {\n    if n0.Next == nil {\n        return\n    }\n    // n0 -> P -> n1\n    P := n0.Next\n    n1 := P.Next\n    n0.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) {\n    if n0.next == nil {\n        return\n    }\n    // n0 -> P -> n1\n    let P = n0.next\n    let n1 = P?.next\n    n0.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) {\n    if (!n0.next) return;\n    // n0 -> P -> n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.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 {\n    if (!n0.next) {\n        return;\n    }\n    // n0 -> P -> n1\n    const P = n0.next;\n    const n1 = P.next;\n    n0.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) {\n  if (n0.next == null) return;\n  // n0 -> P -> n1\n  ListNode P = n0.next!;\n  ListNode? n1 = P.next;\n  n0.next = n1;\n}\n
    linked_list.rs
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\n#[allow(non_snake_case)]\npub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {\n    if n0.borrow().next.is_none() {\n        return;\n    };\n    // n0 -> P -> n1\n    let P = n0.borrow_mut().next.take();\n    if let Some(node) = P {\n        let n1 = node.borrow_mut().next.take();\n        n0.borrow_mut().next = n1;\n    }\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 removeItem(ListNode *n0) {\n    if (!n0->next)\n        return;\n    // n0 -> P -> n1\n    ListNode *P = n0->next;\n    ListNode *n1 = P->next;\n    n0->next = n1;\n    // \u91ca\u653e\u5185\u5b58\n    free(P);\n}\n
    linked_list.kt
    /* \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 */\nfun remove(n0: ListNode?) {\n    val p = n0?.next\n    val n1 = p?.next\n    n0?.next = n1\n}\n
    linked_list.rb
    ### \u5220\u9664\u94fe\u8868\u7684\u8282\u70b9 n0 \u4e4b\u540e\u7684\u9996\u4e2a\u8282\u70b9 ###\ndef remove(n0)\n  return if n0.next.nil?\n\n  # n0 -> remove_node -> n1\n  remove_node = n0.next\n  n1 = remove_node.next\n  n0.next = n1\nend\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 {\n    if (n0.?.next == null) return;\n    // n0 -> P -> n1\n    var P = n0.?.next;\n    var n1 = P.?.next;\n    n0.?.next = n1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#4","title":"4. \u00a0 \u8bbf\u95ee\u8282\u70b9","text":"

    \u5728\u94fe\u8868\u4e2d\u8bbf\u95ee\u8282\u70b9\u7684\u6548\u7387\u8f83\u4f4e\u3002\u5982\u4e0a\u4e00\u8282\u6240\u8ff0\uff0c\u6211\u4eec\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u4e0b\u8bbf\u95ee\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u5143\u7d20\u3002\u94fe\u8868\u5219\u4e0d\u7136\uff0c\u7a0b\u5e8f\u9700\u8981\u4ece\u5934\u8282\u70b9\u51fa\u53d1\uff0c\u9010\u4e2a\u5411\u540e\u904d\u5386\uff0c\u76f4\u81f3\u627e\u5230\u76ee\u6807\u8282\u70b9\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u8bbf\u95ee\u94fe\u8868\u7684\u7b2c \\(i\\) \u4e2a\u8282\u70b9\u9700\u8981\u5faa\u73af \\(i - 1\\) \u8f6e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linked_list.py
    def access(head: ListNode, index: int) -> ListNode | None:\n    \"\"\"\u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9\"\"\"\n    for _ in range(index):\n        if not head:\n            return None\n        head = head.next\n    return head\n
    linked_list.cpp
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == nullptr)\n            return nullptr;\n        head = head->next;\n    }\n    return head;\n}\n
    linked_list.java
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode access(ListNode head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.cs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? Access(ListNode? head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == null)\n            return null;\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.go
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunc access(head *ListNode, index int) *ListNode {\n    for i := 0; i < index; i++ {\n        if head == nil {\n            return nil\n        }\n        head = head.Next\n    }\n    return 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? {\n    var head: ListNode? = head\n    for _ in 0 ..< index {\n        if head == nil {\n            return nil\n        }\n        head = head?.next\n    }\n    return head\n}\n
    linked_list.js
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfunction access(head, index) {\n    for (let i = 0; i < index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return 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 {\n    for (let i = 0; i < index; i++) {\n        if (!head) {\n            return null;\n        }\n        head = head.next;\n    }\n    return head;\n}\n
    linked_list.dart
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode? access(ListNode? head, int index) {\n  for (var i = 0; i < index; i++) {\n    if (head == null) return null;\n    head = head.next;\n  }\n  return head;\n}\n
    linked_list.rs
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\npub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {\n    if index <= 0 {\n        return head;\n    };\n    if let Some(node) = &head.borrow().next {\n        return access(node.clone(), index - 1);\n    }\n\n    return head;\n}\n
    linked_list.c
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nListNode *access(ListNode *head, int index) {\n    for (int i = 0; i < index; i++) {\n        if (head == NULL)\n            return NULL;\n        head = head->next;\n    }\n    return head;\n}\n
    linked_list.kt
    /* \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 */\nfun access(head: ListNode?, index: Int): ListNode? {\n    var h = head\n    for (i in 0..<index) {\n        h = h?.next\n    }\n    return h\n}\n
    linked_list.rb
    ### \u8bbf\u95ee\u94fe\u8868\u4e2d\u7d22\u5f15\u4e3a index \u7684\u8282\u70b9 ###\ndef access(head, index)\n  for i in 0...index\n    return nil if head.nil?\n    head = head.next\n  end\n\n  head\nend\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) {\n    var head = node;\n    var i: i32 = 0;\n    while (i < index) : (i += 1) {\n        head = head.?.next;\n        if (head == null) return null;\n    }\n    return head;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#5","title":"5. \u00a0 \u67e5\u627e\u8282\u70b9","text":"

    \u904d\u5386\u94fe\u8868\uff0c\u67e5\u627e\u5176\u4e2d\u503c\u4e3a target \u7684\u8282\u70b9\uff0c\u8f93\u51fa\u8be5\u8282\u70b9\u5728\u94fe\u8868\u4e2d\u7684\u7d22\u5f15\u3002\u6b64\u8fc7\u7a0b\u4e5f\u5c5e\u4e8e\u7ebf\u6027\u67e5\u627e\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    index = 0\n    while head:\n        if head.val == target:\n            return index\n        head = head.next\n        index += 1\n    return -1\n
    linked_list.cpp
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode *head, int target) {\n    int index = 0;\n    while (head != nullptr) {\n        if (head->val == target)\n            return index;\n        head = head->next;\n        index++;\n    }\n    return -1;\n}\n
    linked_list.java
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nint find(ListNode head, int target) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -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) {\n    int index = 0;\n    while (head != null) {\n        if (head.val == target)\n            return index;\n        head = head.next;\n        index++;\n    }\n    return -1;\n}\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 {\n    index := 0\n    for head != nil {\n        if head.Val == target {\n            return index\n        }\n        head = head.Next\n        index++\n    }\n    return -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 {\n    var head: ListNode? = head\n    var index = 0\n    while head != nil {\n        if head?.val == target {\n            return index\n        }\n        head = head?.next\n        index += 1\n    }\n    return -1\n}\n
    linked_list.js
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfunction find(head, target) {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -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 {\n    let index = 0;\n    while (head !== null) {\n        if (head.val === target) {\n            return index;\n        }\n        head = head.next;\n        index += 1;\n    }\n    return -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) {\n  int index = 0;\n  while (head != null) {\n    if (head.val == target) {\n      return index;\n    }\n    head = head.next;\n    index++;\n  }\n  return -1;\n}\n
    linked_list.rs
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\npub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {\n    if head.borrow().val == target {\n        return index;\n    };\n    if let Some(node) = &head.borrow_mut().next {\n        return find(node.clone(), target, index + 1);\n    }\n    return -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) {\n    int index = 0;\n    while (head) {\n        if (head->val == target)\n            return index;\n        head = head->next;\n        index++;\n    }\n    return -1;\n}\n
    linked_list.kt
    /* \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 */\nfun find(head: ListNode?, target: Int): Int {\n    var index = 0\n    var h = head\n    while (h != null) {\n        if (h.value == target) return index\n        h = h.next\n        index++\n    }\n    return -1\n}\n
    linked_list.rb
    ### \u5728\u94fe\u8868\u4e2d\u67e5\u627e\u503c\u4e3a target \u7684\u9996\u4e2a\u8282\u70b9 ###\ndef find(head, target)\n  index = 0\n  while head\n    return index if head.val == target\n    head = head.next\n    index += 1\n  end\n\n  -1\nend\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 {\n    var head = node;\n    var index: i32 = 0;\n    while (head != null) {\n        if (head.?.val == target) return index;\n        head = head.?.next;\n        index += 1;\n    }\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/linked_list/#422-vs","title":"4.2.2 \u00a0 \u6570\u7ec4 vs. \u94fe\u8868","text":"

    \u8868 4-1 \u603b\u7ed3\u4e86\u6570\u7ec4\u548c\u94fe\u8868\u7684\u5404\u9879\u7279\u70b9\u5e76\u5bf9\u6bd4\u4e86\u64cd\u4f5c\u6548\u7387\u3002\u7531\u4e8e\u5b83\u4eec\u91c7\u7528\u4e24\u79cd\u76f8\u53cd\u7684\u5b58\u50a8\u7b56\u7565\uff0c\u56e0\u6b64\u5404\u79cd\u6027\u8d28\u548c\u64cd\u4f5c\u6548\u7387\u4e5f\u5448\u73b0\u5bf9\u7acb\u7684\u7279\u70b9\u3002

    \u8868 4-1 \u00a0 \u6570\u7ec4\u4e0e\u94fe\u8868\u7684\u6548\u7387\u5bf9\u6bd4

    \u6570\u7ec4 \u94fe\u8868 \u5b58\u50a8\u65b9\u5f0f \u8fde\u7eed\u5185\u5b58\u7a7a\u95f4 \u5206\u6563\u5185\u5b58\u7a7a\u95f4 \u5bb9\u91cf\u6269\u5c55 \u957f\u5ea6\u4e0d\u53ef\u53d8 \u53ef\u7075\u6d3b\u6269\u5c55 \u5185\u5b58\u6548\u7387 \u5143\u7d20\u5360\u7528\u5185\u5b58\u5c11\u3001\u4f46\u53ef\u80fd\u6d6a\u8d39\u7a7a\u95f4 \u5143\u7d20\u5360\u7528\u5185\u5b58\u591a \u8bbf\u95ee\u5143\u7d20 \\(O(1)\\) \\(O(n)\\) \u6dfb\u52a0\u5143\u7d20 \\(O(n)\\) \\(O(1)\\) \u5220\u9664\u5143\u7d20 \\(O(n)\\) \\(O(1)\\)"},{"location":"chapter_array_and_linkedlist/linked_list/#423","title":"4.2.3 \u00a0 \u5e38\u89c1\u94fe\u8868\u7c7b\u578b","text":"

    \u5982\u56fe 4-8 \u6240\u793a\uff0c\u5e38\u89c1\u7684\u94fe\u8868\u7c7b\u578b\u5305\u62ec\u4e09\u79cd\u3002

    • \u5355\u5411\u94fe\u8868\uff1a\u5373\u524d\u9762\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\u5f15\u7528\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\u79f0\u4e3a\u5c3e\u8282\u70b9\uff0c\u5c3e\u8282\u70b9\u6307\u5411\u7a7a None \u3002
    • \u73af\u5f62\u94fe\u8868\uff1a\u5982\u679c\u6211\u4eec\u4ee4\u5355\u5411\u94fe\u8868\u7684\u5c3e\u8282\u70b9\u6307\u5411\u5934\u8282\u70b9\uff08\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\uff1a\u4e0e\u5355\u5411\u94fe\u8868\u76f8\u6bd4\uff0c\u53cc\u5411\u94fe\u8868\u8bb0\u5f55\u4e86\u4e24\u4e2a\u65b9\u5411\u7684\u5f15\u7528\u3002\u53cc\u5411\u94fe\u8868\u7684\u8282\u70b9\u5b9a\u4e49\u540c\u65f6\u5305\u542b\u6307\u5411\u540e\u7ee7\u8282\u70b9\uff08\u4e0b\u4e00\u4e2a\u8282\u70b9\uff09\u548c\u524d\u9a71\u8282\u70b9\uff08\u4e0a\u4e00\u4e2a\u8282\u70b9\uff09\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class ListNode:\n    \"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # \u8282\u70b9\u503c\n        self.next: ListNode | None = None  # \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n        self.prev: ListNode | None = None  # \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct ListNode {\n    int val;         // \u8282\u70b9\u503c\n    ListNode *next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n    ListNode *prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n    ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // \u6784\u9020\u51fd\u6570\n};\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    int val;        // \u8282\u70b9\u503c\n    ListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    ListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n    ListNode(int x) { val = x; }  // \u6784\u9020\u51fd\u6570\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode(int x) {  // \u6784\u9020\u51fd\u6570\n    int val = x;    // \u8282\u70b9\u503c\n    ListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    ListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype DoublyListNode struct {\n    Val  int             // \u8282\u70b9\u503c\n    Next *DoublyListNode // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n    Prev *DoublyListNode // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n}\n\n// NewDoublyListNode \u521d\u59cb\u5316\nfunc NewDoublyListNode(val int) *DoublyListNode {\n    return &DoublyListNode{\n        Val:  val,\n        Next: nil,\n        Prev: nil,\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    var val: Int // \u8282\u70b9\u503c\n    var next: ListNode? // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    var prev: ListNode? // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n\n    init(x: Int) { // \u6784\u9020\u51fd\u6570\n        val = x\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    constructor(val, next, prev) {\n        this.val = val  ===  undefined ? 0 : val;        // \u8282\u70b9\u503c\n        this.next = next  ===  undefined ? null : next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n        this.prev = prev  ===  undefined ? null : prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    val: number;\n    next: ListNode | null;\n    prev: ListNode | null;\n    constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {\n        this.val = val  ===  undefined ? 0 : val;        // \u8282\u70b9\u503c\n        this.next = next  ===  undefined ? null : next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n        this.prev = prev  ===  undefined ? null : prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\nclass ListNode {\n    int val;        // \u8282\u70b9\u503c\n    ListNode next;  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    ListNode prev;  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n    ListNode(this.val, [this.next, this.prev]);  // \u6784\u9020\u51fd\u6570\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\u578b */\n#[derive(Debug)]\nstruct ListNode {\n    val: i32, // \u8282\u70b9\u503c\n    next: Option<Rc<RefCell<ListNode>>>, // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n    prev: Option<Rc<RefCell<ListNode>>>, // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nimpl ListNode {\n    fn new(val: i32) -> Self {\n        ListNode {\n            val,\n            next: None,\n            prev: None,\n        }\n    }\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct ListNode {\n    int val;               // \u8282\u70b9\u503c\n    struct ListNode *next; // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n    struct ListNode *prev; // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n} ListNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nListNode *newListNode(int val) {\n    ListNode *node;\n    node = (ListNode *) malloc(sizeof(ListNode));\n    node->val = val;\n    node->next = NULL;\n    node->prev = NULL;\n    return node;\n}\n
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b */\n// \u6784\u9020\u65b9\u6cd5\nclass ListNode(x: Int) {\n    val _val: Int = x           // \u8282\u70b9\u503c\n    val next: ListNode? = null  // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n    val prev: ListNode? = null  // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n}\n
    # \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\nclass ListNode\n  attr_accessor :val    # \u8282\u70b9\u503c\n  attr_accessor :next   # \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u5f15\u7528\n  attr_accessor :prev   # \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u5f15\u7528\n\n  def initialize(val=0, next_node=nil, prev_node=nil)\n    @val = val\n    @next = next_node\n    @prev = prev_node\n  end\nend\n
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\u7c7b\npub fn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = 0, // \u8282\u70b9\u503c\n        next: ?*Self = null, // \u6307\u5411\u540e\u7ee7\u8282\u70b9\u7684\u6307\u9488\n        prev: ?*Self = null, // \u6307\u5411\u524d\u9a71\u8282\u70b9\u7684\u6307\u9488\n\n        // \u6784\u9020\u51fd\u6570\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n            self.prev = null;\n        }\n    };\n}\n

    \u56fe 4-8 \u00a0 \u5e38\u89c1\u94fe\u8868\u79cd\u7c7b

    "},{"location":"chapter_array_and_linkedlist/linked_list/#424","title":"4.2.4 \u00a0 \u94fe\u8868\u5178\u578b\u5e94\u7528","text":"

    \u5355\u5411\u94fe\u8868\u901a\u5e38\u7528\u4e8e\u5b9e\u73b0\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u548c\u56fe\u7b49\u6570\u636e\u7ed3\u6784\u3002

    • \u6808\u4e0e\u961f\u5217\uff1a\u5f53\u63d2\u5165\u548c\u5220\u9664\u64cd\u4f5c\u90fd\u5728\u94fe\u8868\u7684\u4e00\u7aef\u8fdb\u884c\u65f6\uff0c\u5b83\u8868\u73b0\u51fa\u5148\u8fdb\u540e\u51fa\u7684\u7279\u6027\uff0c\u5bf9\u5e94\u6808\uff1b\u5f53\u63d2\u5165\u64cd\u4f5c\u5728\u94fe\u8868\u7684\u4e00\u7aef\u8fdb\u884c\uff0c\u5220\u9664\u64cd\u4f5c\u5728\u94fe\u8868\u7684\u53e6\u4e00\u7aef\u8fdb\u884c\uff0c\u5b83\u8868\u73b0\u51fa\u5148\u8fdb\u5148\u51fa\u7684\u7279\u6027\uff0c\u5bf9\u5e94\u961f\u5217\u3002
    • \u54c8\u5e0c\u8868\uff1a\u94fe\u5f0f\u5730\u5740\u662f\u89e3\u51b3\u54c8\u5e0c\u51b2\u7a81\u7684\u4e3b\u6d41\u65b9\u6848\u4e4b\u4e00\uff0c\u5728\u8be5\u65b9\u6848\u4e2d\uff0c\u6240\u6709\u51b2\u7a81\u7684\u5143\u7d20\u90fd\u4f1a\u88ab\u653e\u5230\u4e00\u4e2a\u94fe\u8868\u4e2d\u3002
    • \u56fe\uff1a\u90bb\u63a5\u8868\u662f\u8868\u793a\u56fe\u7684\u4e00\u79cd\u5e38\u7528\u65b9\u5f0f\uff0c\u5176\u4e2d\u56fe\u7684\u6bcf\u4e2a\u9876\u70b9\u90fd\u4e0e\u4e00\u4e2a\u94fe\u8868\u76f8\u5173\u8054\uff0c\u94fe\u8868\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\u90fd\u4ee3\u8868\u4e0e\u8be5\u9876\u70b9\u76f8\u8fde\u7684\u5176\u4ed6\u9876\u70b9\u3002

    \u53cc\u5411\u94fe\u8868\u5e38\u7528\u4e8e\u9700\u8981\u5feb\u901f\u67e5\u627e\u524d\u4e00\u4e2a\u548c\u540e\u4e00\u4e2a\u5143\u7d20\u7684\u573a\u666f\u3002

    • \u9ad8\u7ea7\u6570\u636e\u7ed3\u6784\uff1a\u6bd4\u5982\u5728\u7ea2\u9ed1\u6811\u3001B \u6811\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u8bbf\u95ee\u8282\u70b9\u7684\u7236\u8282\u70b9\uff0c\u8fd9\u53ef\u4ee5\u901a\u8fc7\u5728\u8282\u70b9\u4e2d\u4fdd\u5b58\u4e00\u4e2a\u6307\u5411\u7236\u8282\u70b9\u7684\u5f15\u7528\u6765\u5b9e\u73b0\uff0c\u7c7b\u4f3c\u4e8e\u53cc\u5411\u94fe\u8868\u3002
    • \u6d4f\u89c8\u5668\u5386\u53f2\uff1a\u5728\u7f51\u9875\u6d4f\u89c8\u5668\u4e2d\uff0c\u5f53\u7528\u6237\u70b9\u51fb\u524d\u8fdb\u6216\u540e\u9000\u6309\u94ae\u65f6\uff0c\u6d4f\u89c8\u5668\u9700\u8981\u77e5\u9053\u7528\u6237\u8bbf\u95ee\u8fc7\u7684\u524d\u4e00\u4e2a\u548c\u540e\u4e00\u4e2a\u7f51\u9875\u3002\u53cc\u5411\u94fe\u8868\u7684\u7279\u6027\u4f7f\u5f97\u8fd9\u79cd\u64cd\u4f5c\u53d8\u5f97\u7b80\u5355\u3002
    • LRU \u7b97\u6cd5\uff1a\u5728\u7f13\u5b58\u6dd8\u6c70\uff08LRU\uff09\u7b97\u6cd5\u4e2d\uff0c\u6211\u4eec\u9700\u8981\u5feb\u901f\u627e\u5230\u6700\u8fd1\u6700\u5c11\u4f7f\u7528\u7684\u6570\u636e\uff0c\u4ee5\u53ca\u652f\u6301\u5feb\u901f\u6dfb\u52a0\u548c\u5220\u9664\u8282\u70b9\u3002\u8fd9\u65f6\u5019\u4f7f\u7528\u53cc\u5411\u94fe\u8868\u5c31\u975e\u5e38\u5408\u9002\u3002

    \u73af\u5f62\u94fe\u8868\u5e38\u7528\u4e8e\u9700\u8981\u5468\u671f\u6027\u64cd\u4f5c\u7684\u573a\u666f\uff0c\u6bd4\u5982\u64cd\u4f5c\u7cfb\u7edf\u7684\u8d44\u6e90\u8c03\u5ea6\u3002

    • \u65f6\u95f4\u7247\u8f6e\u8f6c\u8c03\u5ea6\u7b97\u6cd5\uff1a\u5728\u64cd\u4f5c\u7cfb\u7edf\u4e2d\uff0c\u65f6\u95f4\u7247\u8f6e\u8f6c\u8c03\u5ea6\u7b97\u6cd5\u662f\u4e00\u79cd\u5e38\u89c1\u7684 CPU \u8c03\u5ea6\u7b97\u6cd5\uff0c\u5b83\u9700\u8981\u5bf9\u4e00\u7ec4\u8fdb\u7a0b\u8fdb\u884c\u5faa\u73af\u3002\u6bcf\u4e2a\u8fdb\u7a0b\u88ab\u8d4b\u4e88\u4e00\u4e2a\u65f6\u95f4\u7247\uff0c\u5f53\u65f6\u95f4\u7247\u7528\u5b8c\u65f6\uff0cCPU \u5c06\u5207\u6362\u5230\u4e0b\u4e00\u4e2a\u8fdb\u7a0b\u3002\u8fd9\u79cd\u5faa\u73af\u64cd\u4f5c\u53ef\u4ee5\u901a\u8fc7\u73af\u5f62\u94fe\u8868\u6765\u5b9e\u73b0\u3002
    • \u6570\u636e\u7f13\u51b2\u533a\uff1a\u5728\u67d0\u4e9b\u6570\u636e\u7f13\u51b2\u533a\u7684\u5b9e\u73b0\u4e2d\uff0c\u4e5f\u53ef\u80fd\u4f1a\u4f7f\u7528\u73af\u5f62\u94fe\u8868\u3002\u6bd4\u5982\u5728\u97f3\u9891\u3001\u89c6\u9891\u64ad\u653e\u5668\u4e2d\uff0c\u6570\u636e\u6d41\u53ef\u80fd\u4f1a\u88ab\u5206\u6210\u591a\u4e2a\u7f13\u51b2\u5757\u5e76\u653e\u5165\u4e00\u4e2a\u73af\u5f62\u94fe\u8868\uff0c\u4ee5\u4fbf\u5b9e\u73b0\u65e0\u7f1d\u64ad\u653e\u3002
    "},{"location":"chapter_array_and_linkedlist/list/","title":"4.3 \u00a0 \u5217\u8868","text":"

    \u300c\u5217\u8868 list\u300d\u662f\u4e00\u4e2a\u62bd\u8c61\u7684\u6570\u636e\u7ed3\u6784\u6982\u5ff5\uff0c\u5b83\u8868\u793a\u5143\u7d20\u7684\u6709\u5e8f\u96c6\u5408\uff0c\u652f\u6301\u5143\u7d20\u8bbf\u95ee\u3001\u4fee\u6539\u3001\u6dfb\u52a0\u3001\u5220\u9664\u548c\u904d\u5386\u7b49\u64cd\u4f5c\uff0c\u65e0\u987b\u4f7f\u7528\u8005\u8003\u8651\u5bb9\u91cf\u9650\u5236\u7684\u95ee\u9898\u3002\u5217\u8868\u53ef\u4ee5\u57fa\u4e8e\u94fe\u8868\u6216\u6570\u7ec4\u5b9e\u73b0\u3002

    • \u94fe\u8868\u5929\u7136\u53ef\u4ee5\u770b\u4f5c\u4e00\u4e2a\u5217\u8868\uff0c\u5176\u652f\u6301\u5143\u7d20\u589e\u5220\u67e5\u6539\u64cd\u4f5c\uff0c\u5e76\u4e14\u53ef\u4ee5\u7075\u6d3b\u52a8\u6001\u6269\u5bb9\u3002
    • \u6570\u7ec4\u4e5f\u652f\u6301\u5143\u7d20\u589e\u5220\u67e5\u6539\uff0c\u4f46\u7531\u4e8e\u5176\u957f\u5ea6\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u53ea\u80fd\u770b\u4f5c\u4e00\u4e2a\u5177\u6709\u957f\u5ea6\u9650\u5236\u7684\u5217\u8868\u3002

    \u5f53\u4f7f\u7528\u6570\u7ec4\u5b9e\u73b0\u5217\u8868\u65f6\uff0c\u957f\u5ea6\u4e0d\u53ef\u53d8\u7684\u6027\u8d28\u4f1a\u5bfc\u81f4\u5217\u8868\u7684\u5b9e\u7528\u6027\u964d\u4f4e\u3002\u8fd9\u662f\u56e0\u4e3a\u6211\u4eec\u901a\u5e38\u65e0\u6cd5\u4e8b\u5148\u786e\u5b9a\u9700\u8981\u5b58\u50a8\u591a\u5c11\u6570\u636e\uff0c\u4ece\u800c\u96be\u4ee5\u9009\u62e9\u5408\u9002\u7684\u5217\u8868\u957f\u5ea6\u3002\u82e5\u957f\u5ea6\u8fc7\u5c0f\uff0c\u5219\u5f88\u53ef\u80fd\u65e0\u6cd5\u6ee1\u8db3\u4f7f\u7528\u9700\u6c42\uff1b\u82e5\u957f\u5ea6\u8fc7\u5927\uff0c\u5219\u4f1a\u9020\u6210\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u3002

    \u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u300c\u52a8\u6001\u6570\u7ec4 dynamic array\u300d\u6765\u5b9e\u73b0\u5217\u8868\u3002\u5b83\u7ee7\u627f\u4e86\u6570\u7ec4\u7684\u5404\u9879\u4f18\u70b9\uff0c\u5e76\u4e14\u53ef\u4ee5\u5728\u7a0b\u5e8f\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u8fdb\u884c\u52a8\u6001\u6269\u5bb9\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\u4e2d\u7684\u6807\u51c6\u5e93\u63d0\u4f9b\u7684\u5217\u8868\u662f\u57fa\u4e8e\u52a8\u6001\u6570\u7ec4\u5b9e\u73b0\u7684\uff0c\u4f8b\u5982 Python \u4e2d\u7684 list \u3001Java \u4e2d\u7684 ArrayList \u3001C++ \u4e2d\u7684 vector \u548c C# \u4e2d\u7684 List \u7b49\u3002\u5728\u63a5\u4e0b\u6765\u7684\u8ba8\u8bba\u4e2d\uff0c\u6211\u4eec\u5c06\u628a\u201c\u5217\u8868\u201d\u548c\u201c\u52a8\u6001\u6570\u7ec4\u201d\u89c6\u4e3a\u7b49\u540c\u7684\u6982\u5ff5\u3002

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

    \u6211\u4eec\u901a\u5e38\u4f7f\u7528\u201c\u65e0\u521d\u59cb\u503c\u201d\u548c\u201c\u6709\u521d\u59cb\u503c\u201d\u8fd9\u4e24\u79cd\u521d\u59cb\u5316\u65b9\u6cd5\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u521d\u59cb\u5316\u5217\u8868\n# \u65e0\u521d\u59cb\u503c\nnums1: list[int] = []\n# \u6709\u521d\u59cb\u503c\nnums: list[int] = [1, 3, 2, 5, 4]\n
    list.cpp
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u9700\u6ce8\u610f\uff0cC++ \u4e2d vector \u5373\u662f\u672c\u6587\u63cf\u8ff0\u7684 nums\n// \u65e0\u521d\u59cb\u503c\nvector<int> nums1;\n// \u6709\u521d\u59cb\u503c\nvector<int> nums = { 1, 3, 2, 5, 4 };\n
    list.java
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<Integer> nums1 = 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> nums = new ArrayList<>(Arrays.asList(numbers));\n
    list.cs
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<int> nums1 = [];\n// \u6709\u521d\u59cb\u503c\nint[] numbers = [1, 3, 2, 5, 4];\nList<int> nums = [.. numbers];\n
    list_test.go
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nnums1 := []int{}\n// \u6709\u521d\u59cb\u503c\nnums := []int{1, 3, 2, 5, 4}\n
    list.swift
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nlet nums1: [Int] = []\n// \u6709\u521d\u59cb\u503c\nvar nums = [1, 3, 2, 5, 4]\n
    list.js
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nconst nums1 = [];\n// \u6709\u521d\u59cb\u503c\nconst nums = [1, 3, 2, 5, 4];\n
    list.ts
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nconst nums1: number[] = [];\n// \u6709\u521d\u59cb\u503c\nconst nums: number[] = [1, 3, 2, 5, 4];\n
    list.dart
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nList<int> nums1 = [];\n// \u6709\u521d\u59cb\u503c\nList<int> nums = [1, 3, 2, 5, 4];\n
    list.rs
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nlet nums1: Vec<i32> = Vec::new();\n// \u6709\u521d\u59cb\u503c\nlet nums: Vec<i32> = vec![1, 3, 2, 5, 4];\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.kt
    /* \u521d\u59cb\u5316\u5217\u8868 */\n// \u65e0\u521d\u59cb\u503c\nvar nums1 = listOf<Int>()\n// \u6709\u521d\u59cb\u503c\nvar numbers = arrayOf(1, 3, 2, 5, 4)\nvar nums = numbers.toMutableList()\n
    list.rb
    # \u521d\u59cb\u5316\u5217\u8868\n# \u65e0\u521d\u59cb\u503c\nnums1 = []\n# \u6709\u521d\u59cb\u503c\nnums = [1, 3, 2, 5, 4]\n
    list.zig
    // \u521d\u59cb\u5316\u5217\u8868\nvar nums = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nums.deinit();\ntry nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#2","title":"2. \u00a0 \u8bbf\u95ee\u5143\u7d20","text":"

    \u5217\u8868\u672c\u8d28\u4e0a\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u8bbf\u95ee\u5143\u7d20\nnum: int = nums[1]  # \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n# \u66f4\u65b0\u5143\u7d20\nnums[1] = 0    # \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.cpp
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.java
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = nums.get(1);  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums.set(1, 0);  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.cs
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list_test.go
    /* \u8bbf\u95ee\u5143\u7d20 */\nnum := nums[1]  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0     // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.swift
    /* \u8bbf\u95ee\u5143\u7d20 */\nlet num = nums[1] // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0 // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.js
    /* \u8bbf\u95ee\u5143\u7d20 */\nconst num = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.ts
    /* \u8bbf\u95ee\u5143\u7d20 */\nconst num: number = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.dart
    /* \u8bbf\u95ee\u5143\u7d20 */\nint num = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0;  // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.rs
    /* \u8bbf\u95ee\u5143\u7d20 */\nlet num: i32 = nums[1];  // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[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.kt
    /* \u8bbf\u95ee\u5143\u7d20 */\nval num = nums[1]       // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n/* \u66f4\u65b0\u5143\u7d20 */\nnums[1] = 0             // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.rb
    # \u8bbf\u95ee\u5143\u7d20\nnum = nums[1] # \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n# \u66f4\u65b0\u5143\u7d20\nnums[1] = 0 # \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    list.zig
    // \u8bbf\u95ee\u5143\u7d20\nvar num = nums.items[1]; // \u8bbf\u95ee\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\n\n// \u66f4\u65b0\u5143\u7d20\nnums.items[1] = 0; // \u5c06\u7d22\u5f15 1 \u5904\u7684\u5143\u7d20\u66f4\u65b0\u4e3a 0\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#3","title":"3. \u00a0 \u63d2\u5165\u4e0e\u5220\u9664\u5143\u7d20","text":"

    \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

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

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#4","title":"4. \u00a0 \u904d\u5386\u5217\u8868","text":"

    \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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\ncount = 0\nfor i in range(len(nums)):\n    count += nums[i]\n\n# \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\nfor num in nums:\n    count += num\n
    list.cpp
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < nums.size(); i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (int num : nums) {\n    count += num;\n}\n
    list.java
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < nums.size(); i++) {\n    count += nums.get(i);\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\nfor (int num : nums) {\n    count += num;\n}\n
    list.cs
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (int i = 0; i < nums.Count; i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nforeach (int num in nums) {\n    count += num;\n}\n
    list_test.go
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\ncount := 0\nfor i := 0; i < len(nums); i++ {\n    count += nums[i]\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0\nfor _, num := range nums {\n    count += num\n}\n
    list.swift
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nvar count = 0\nfor i in nums.indices {\n    count += nums[i]\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0\nfor num in nums {\n    count += num\n}\n
    list.js
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nlet count = 0;\nfor (let i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n
    list.ts
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nlet count = 0;\nfor (let i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (const num of nums) {\n    count += num;\n}\n
    list.dart
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nint count = 0;\nfor (var i = 0; i < nums.length; i++) {\n    count += nums[i];\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\ncount = 0;\nfor (var num in nums) {\n    count += num;\n}\n
    list.rs
    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\nlet mut _count = 0;\nfor i in 0..nums.len() {\n    _count += nums[i];\n}\n\n// \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\n_count = 0;\nfor num in &nums {\n    _count += num;\n}\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.kt
    /* \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868 */\nvar count = 0\nfor (i in nums.indices) {\n    count += nums[i]\n}\n\n/* \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20 */\nfor (num in nums) {\n    count += num\n}\n
    list.rb
    # \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\ncount = 0\nfor i in 0...nums.length\n    count += nums[i]\nend\n\n# \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\ncount = 0\nfor num in nums\n    count += num\nend\n
    list.zig
    // \u901a\u8fc7\u7d22\u5f15\u904d\u5386\u5217\u8868\nvar count: i32 = 0;\nvar i: i32 = 0;\nwhile (i < nums.items.len) : (i += 1) {\n    count += nums[i];\n}\n\n// \u76f4\u63a5\u904d\u5386\u5217\u8868\u5143\u7d20\ncount = 0;\nfor (nums.items) |num| {\n    count += num;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#5","title":"5. \u00a0 \u62fc\u63a5\u5217\u8868","text":"

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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nnums1: list[int] = [6, 8, 7, 10, 9]\nnums += nums1  # \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.cpp
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nvector<int> nums1 = { 6, 8, 7, 10, 9 };\n// \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\nnums.insert(nums.end(), nums1.begin(), nums1.end());\n
    list.java
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<Integer> nums1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));\nnums.addAll(nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.cs
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<int> nums1 = [6, 8, 7, 10, 9];\nnums.AddRange(nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list_test.go
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nnums1 := []int{6, 8, 7, 10, 9}\nnums = append(nums, nums1...)  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.swift
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nlet nums1 = [6, 8, 7, 10, 9]\nnums.append(contentsOf: nums1) // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.js
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nconst nums1 = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.ts
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nconst nums1: number[] = [6, 8, 7, 10, 9];\nnums.push(...nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.dart
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nList<int> nums1 = [6, 8, 7, 10, 9];\nnums.addAll(nums1);  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.rs
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nlet nums1: Vec<i32> = vec![6, 8, 7, 10, 9];\nnums.extend(nums1);\n
    list.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u52a8\u6001\u6570\u7ec4\n
    list.kt
    /* \u62fc\u63a5\u4e24\u4e2a\u5217\u8868 */\nval nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()\nnums.addAll(nums1)  // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    list.rb
    # \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nnums1 = [6, 8, 7, 10, 9]\nnums += nums1\n
    list.zig
    // \u62fc\u63a5\u4e24\u4e2a\u5217\u8868\nvar nums1 = std.ArrayList(i32).init(std.heap.page_allocator);\ndefer nums1.deinit();\ntry nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });\ntry nums.insertSlice(nums.items.len, nums1.items); // \u5c06\u5217\u8868 nums1 \u62fc\u63a5\u5230 nums \u4e4b\u540e\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#6","title":"6. \u00a0 \u6392\u5e8f\u5217\u8868","text":"

    \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\u67e5\u7684\u201c\u4e8c\u5206\u67e5\u627e\u201d\u548c\u201c\u53cc\u6307\u9488\u201d\u7b97\u6cd5\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig list.py
    # \u6392\u5e8f\u5217\u8868\nnums.sort()  # \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.cpp
    /* \u6392\u5e8f\u5217\u8868 */\nsort(nums.begin(), nums.end());  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.java
    /* \u6392\u5e8f\u5217\u8868 */\nCollections.sort(nums);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.cs
    /* \u6392\u5e8f\u5217\u8868 */\nnums.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(nums)  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.swift
    /* \u6392\u5e8f\u5217\u8868 */\nnums.sort() // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.js
    /* \u6392\u5e8f\u5217\u8868 */\nnums.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 */\nnums.sort((a, b) => a - b);  // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.dart
    /* \u6392\u5e8f\u5217\u8868 */\nnums.sort(); // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.rs
    /* \u6392\u5e8f\u5217\u8868 */\nnums.sort(); // \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.kt
    /* \u6392\u5e8f\u5217\u8868 */\nnums.sort() // \u6392\u5e8f\u540e\uff0c\u5217\u8868\u5143\u7d20\u4ece\u5c0f\u5230\u5927\u6392\u5217\n
    list.rb
    # \u6392\u5e8f\u5217\u8868\nnums = nums.sort { |a, b| a <=> b } # \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, nums.items, {}, comptime std.sort.asc(i32));\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/list/#432","title":"4.3.2 \u00a0 \u5217\u8868\u5b9e\u73b0","text":"

    \u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\u5185\u7f6e\u4e86\u5217\u8868\uff0c\u4f8b\u5982 Java\u3001C++\u3001Python \u7b49\u3002\u5b83\u4eec\u7684\u5b9e\u73b0\u6bd4\u8f83\u590d\u6742\uff0c\u5404\u4e2a\u53c2\u6570\u7684\u8bbe\u5b9a\u4e5f\u975e\u5e38\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

    \u4e3a\u4e86\u52a0\u6df1\u5bf9\u5217\u8868\u5de5\u4f5c\u539f\u7406\u7684\u7406\u89e3\uff0c\u6211\u4eec\u5c1d\u8bd5\u5b9e\u73b0\u4e00\u4e2a\u7b80\u6613\u7248\u5217\u8868\uff0c\u5305\u62ec\u4ee5\u4e0b\u4e09\u4e2a\u91cd\u70b9\u8bbe\u8ba1\u3002

    • \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\u82e5\u63d2\u5165\u5143\u7d20\u65f6\u5217\u8868\u5bb9\u91cf\u5df2\u6ee1\uff0c\u5219\u9700\u8981\u8fdb\u884c\u6269\u5bb9\u3002\u5148\u6839\u636e\u6269\u5bb9\u500d\u6570\u521b\u5efa\u4e00\u4e2a\u66f4\u5927\u7684\u6570\u7ec4\uff0c\u518d\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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_list.py
    class MyList:\n    \"\"\"\u5217\u8868\u7c7b\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._capacity: int = 10  # \u5217\u8868\u5bb9\u91cf\n        self._arr: list[int] = [0] * self._capacity  # \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        self._size: int = 0  # \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        self._extend_ratio: int = 2  # \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\"\"\"\n        return self._size\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u5217\u8868\u5bb9\u91cf\"\"\"\n        return self._capacity\n\n    def get(self, index: int) -> int:\n        \"\"\"\u8bbf\u95ee\u5143\u7d20\"\"\"\n        # \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        return self._arr[index]\n\n    def set(self, num: int, index: int):\n        \"\"\"\u66f4\u65b0\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        self._arr[index] = num\n\n    def add(self, num: int):\n        \"\"\"\u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\"\"\"\n        # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size() == self.capacity():\n            self.extend_capacity()\n        self._arr[self._size] = num\n        self._size += 1\n\n    def insert(self, num: int, index: int):\n        \"\"\"\u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self._size == self.capacity():\n            self.extend_capacity()\n        # \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in range(self._size - 1, index - 1, -1):\n            self._arr[j + 1] = self._arr[j]\n        self._arr[index] = num\n        # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self._size += 1\n\n    def remove(self, index: int) -> int:\n        \"\"\"\u5220\u9664\u5143\u7d20\"\"\"\n        if index < 0 or index >= self._size:\n            raise IndexError(\"\u7d22\u5f15\u8d8a\u754c\")\n        num = self._arr[index]\n        # \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in range(index, self._size - 1):\n            self._arr[j] = self._arr[j + 1]\n        # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self._size -= 1\n        # \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n\n    def extend_capacity(self):\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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)\n        # \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        self._capacity = len(self._arr)\n\n    def to_array(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u6709\u6548\u957f\u5ea6\u7684\u5217\u8868\"\"\"\n        return self._arr[: self._size]\n
    my_list.cpp
    /* \u5217\u8868\u7c7b */\nclass MyList {\n  private:\n    int *arr;             // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    int arrCapacity = 10; // \u5217\u8868\u5bb9\u91cf\n    int arrSize = 0;      // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    int extendRatio = 2;   // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~MyList() {\n        delete[] arr;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    int size() {\n        return arrSize;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    int capacity() {\n        return arrCapacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    int get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    void set(int index, int num) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    void add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size() == capacity())\n            extendCapacity();\n        arr[size()] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    void insert(int index, int num) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size() == capacity())\n            extendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = size() - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    int remove(int index) {\n        if (index < 0 || index >= size())\n            throw out_of_range(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < size() - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    void extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\n        int newCapacity = capacity() * extendRatio;\n        int *tmp = arr;\n        arr = new int[newCapacity];\n        // \u5c06\u539f\u6570\u7ec4\u4e2d\u7684\u6240\u6709\u5143\u7d20\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            arr[i] = tmp[i];\n        }\n        // \u91ca\u653e\u5185\u5b58\n        delete[] tmp;\n        arrCapacity = newCapacity;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Vector \u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> vec(size());\n        for (int i = 0; i < size(); i++) {\n            vec[i] = arr[i];\n        }\n        return vec;\n    }\n};\n
    my_list.java
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private int[] arr; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private int capacity = 10; // \u5217\u8868\u5bb9\u91cf\n    private int size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private int extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public MyList() {\n        arr = new int[capacity];\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\n    public int size() {\n        return size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public int capacity() {\n        return capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public int get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public void set(int index, int num) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public void add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity();\n        arr[size] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public void insert(int index, int num) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = size - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public int remove(int index) {\n        if (index < 0 || index >= size)\n            throw new IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < size - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public 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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = Arrays.copyOf(arr, capacity() * extendRatio);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        capacity = arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public int[] toArray() {\n        int size = size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] arr = new int[size];\n        for (int i = 0; i < size; i++) {\n            arr[i] = get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.cs
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private int[] arr;           // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private int arrCapacity = 10;    // \u5217\u8868\u5bb9\u91cf\n    private int arrSize = 0;         // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private readonly int extendRatio = 2;  // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public MyList() {\n        arr = new int[arrCapacity];\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    public int Size() {\n        return arrSize;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public int Capacity() {\n        return arrCapacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public int Get(int index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        return arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public void Set(int index, int num) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public void Add(int num) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        arr[arrSize] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public void Insert(int index, int num) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (arrSize == arrCapacity)\n            ExtendCapacity();\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (int j = arrSize - 1; j >= index; j--) {\n            arr[j + 1] = arr[j];\n        }\n        arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public int Remove(int index) {\n        if (index < 0 || index >= arrSize)\n            throw new IndexOutOfRangeException(\"\u7d22\u5f15\u8d8a\u754c\");\n        int num = arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (int j = index; j < arrSize - 1; j++) {\n            arr[j] = arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        arrSize--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public void ExtendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a arrCapacity * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        Array.Resize(ref arr, arrCapacity * extendRatio);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        arrCapacity = arr.Length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] arr = new int[arrSize];\n        for (int i = 0; i < arrSize; i++) {\n            arr[i] = Get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.go
    /* \u5217\u8868\u7c7b */\ntype myList struct {\n    arrCapacity int\n    arr         []int\n    arrSize     int\n    extendRatio int\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newMyList() *myList {\n    return &myList{\n        arrCapacity: 10,              // \u5217\u8868\u5bb9\u91cf\n        arr:         make([]int, 10), // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        arrSize:     0,               // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        extendRatio: 2,               // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n    }\n}\n\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\nfunc (l *myList) size() int {\n    return l.arrSize\n}\n\n/*  \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nfunc (l *myList) capacity() int {\n    return l.arrCapacity\n}\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nfunc (l *myList) get(index int) int {\n    // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    return l.arr[index]\n}\n\n/* \u66f4\u65b0\u5143\u7d20 */\nfunc (l *myList) set(num, index int) {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    l.arr[index] = num\n}\n\n/* \u5728\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\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    l.arr[l.arrSize] = num\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize++\n}\n\n/* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nfunc (l *myList) insert(num, index int) {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if l.arrSize == l.arrCapacity {\n        l.extendCapacity()\n    }\n    // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for j := l.arrSize - 1; j >= index; j-- {\n        l.arr[j+1] = l.arr[j]\n    }\n    l.arr[index] = num\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize++\n}\n\n/* \u5220\u9664\u5143\u7d20 */\nfunc (l *myList) remove(index int) int {\n    if index < 0 || index >= l.arrSize {\n        panic(\"\u7d22\u5f15\u8d8a\u754c\")\n    }\n    num := l.arr[index]\n    // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for j := index; j < l.arrSize-1; j++ {\n        l.arr[j] = l.arr[j+1]\n    }\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    l.arrSize--\n    // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    return num\n}\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\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)\n    // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    l.arrCapacity = len(l.arr)\n}\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\n    return l.arr[:l.arrSize]\n}\n
    my_list.swift
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private var arr: [Int] // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private var _capacity: Int // \u5217\u8868\u5bb9\u91cf\n    private var _size: Int // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private let extendRatio: Int // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        _capacity = 10\n        _size = 0\n        extendRatio = 2\n        arr = Array(repeating: 0, count: _capacity)\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    func size() -> Int {\n        _size\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    func capacity() -> Int {\n        _capacity\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    func get(index: Int) -> Int {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\u5219\u629b\u51fa\u9519\u8bef\uff0c\u4e0b\u540c\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        return arr[index]\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    func set(index: Int, num: Int) {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        arr[index] = num\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    func add(num: Int) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if size() == capacity() {\n            extendCapacity()\n        }\n        arr[size()] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size += 1\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    func insert(index: Int, num: Int) {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if size() == capacity() {\n            extendCapacity()\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in (index ..< size()).reversed() {\n            arr[j + 1] = arr[j]\n        }\n        arr[index] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size += 1\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    @discardableResult\n    func remove(index: Int) -> Int {\n        if index < 0 || index >= size() {\n            fatalError(\"\u7d22\u5f15\u8d8a\u754c\")\n        }\n        let num = arr[index]\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in index ..< (size() - 1) {\n            arr[j] = arr[j + 1]\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        _size -= 1\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    func extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = arr + Array(repeating: 0, count: capacity() * (extendRatio - 1))\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        _capacity = arr.count\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    func toArray() -> [Int] {\n        Array(arr.prefix(size()))\n    }\n}\n
    my_list.js
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    #arr = 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\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    #extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#arr = new Array(this.#capacity);\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    size() {\n        return this.#size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    capacity() {\n        return this.#capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    get(index) {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        return this.#arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    set(index, num) {\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        this.#arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    add(num) {\n        // \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\n        this.#arr[this.#size] = num;\n        this.#size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    insert(index, num) {\n        if (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\n        if (this.#size === this.#capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (let j = this.#size - 1; j >= index; j--) {\n            this.#arr[j + 1] = this.#arr[j];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.#arr[index] = num;\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    remove(index) {\n        if (index < 0 || index >= this.#size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        let num = this.#arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (let j = index; j < this.#size - 1; j++) {\n            this.#arr[j] = this.#arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.#size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        this.#arr = this.#arr.concat(\n            new Array(this.capacity() * (this.#extendRatio - 1))\n        );\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        this.#capacity = this.#arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    toArray() {\n        let size = this.size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(size);\n        for (let i = 0; i < size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.ts
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private arr: Array<number>; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private _capacity: number = 10; // \u5217\u8868\u5bb9\u91cf\n    private _size: number = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private extendRatio: number = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.arr = new Array(this._capacity);\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    public size(): number {\n        return this._size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    public capacity(): number {\n        return this._capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    public get(index: number): number {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        return this.arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    public set(index: number, num: number): void {\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        this.arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    public add(num: number): void {\n        // \u5982\u679c\u957f\u5ea6\u7b49\u4e8e\u5bb9\u91cf\uff0c\u5219\u9700\u8981\u6269\u5bb9\n        if (this._size === this._capacity) this.extendCapacity();\n        // \u5c06\u65b0\u5143\u7d20\u6dfb\u52a0\u5230\u5217\u8868\u5c3e\u90e8\n        this.arr[this._size] = num;\n        this._size++;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    public insert(index: number, num: number): void {\n        if (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\n        if (this._size === this._capacity) {\n            this.extendCapacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (let j = this._size - 1; j >= index; j--) {\n            this.arr[j + 1] = this.arr[j];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this.arr[index] = num;\n        this._size++;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    public remove(index: number): number {\n        if (index < 0 || index >= this._size) throw new Error('\u7d22\u5f15\u8d8a\u754c');\n        let num = this.arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (let j = index; j < this._size - 1; j++) {\n            this.arr[j] = this.arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        this._size--;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    public extendCapacity(): void {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        this.arr = this.arr.concat(\n            new Array(this.capacity() * (this.extendRatio - 1))\n        );\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        this._capacity = this.arr.length;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    public toArray(): number[] {\n        let size = this.size();\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(size);\n        for (let i = 0; i < size; i++) {\n            arr[i] = this.get(i);\n        }\n        return arr;\n    }\n}\n
    my_list.dart
    /* \u5217\u8868\u7c7b */\nclass MyList {\n  late List<int> _arr; // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n  int _capacity = 10; // \u5217\u8868\u5bb9\u91cf\n  int _size = 0; // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n  int _extendRatio = 2; // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  MyList() {\n    _arr = List.filled(_capacity, 0);\n  }\n\n  /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n  int size() => _size;\n\n  /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n  int capacity() => _capacity;\n\n  /* \u8bbf\u95ee\u5143\u7d20 */\n  int get(int index) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    return _arr[index];\n  }\n\n  /* \u66f4\u65b0\u5143\u7d20 */\n  void set(int index, int _num) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    _arr[index] = _num;\n  }\n\n  /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n  void add(int _num) {\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if (_size == _capacity) extendCapacity();\n    _arr[_size] = _num;\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size++;\n  }\n\n  /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n  void insert(int index, int _num) {\n    if (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\n    if (_size == _capacity) extendCapacity();\n    // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for (var j = _size - 1; j >= index; j--) {\n      _arr[j + 1] = _arr[j];\n    }\n    _arr[index] = _num;\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size++;\n  }\n\n  /* \u5220\u9664\u5143\u7d20 */\n  int remove(int index) {\n    if (index >= _size) throw RangeError('\u7d22\u5f15\u8d8a\u754c');\n    int _num = _arr[index];\n    // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for (var j = index; j < _size - 1; j++) {\n      _arr[j] = _arr[j + 1];\n    }\n    // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    _size--;\n    // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    return _num;\n  }\n\n  /* \u5217\u8868\u6269\u5bb9 */\n  void extendCapacity() {\n    // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 _extendRatio \u500d\u7684\u65b0\u6570\u7ec4\n    final _newNums = List.filled(_capacity * _extendRatio, 0);\n    // \u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    List.copyRange(_newNums, 0, _arr);\n    // \u66f4\u65b0 _arr \u7684\u5f15\u7528\n    _arr = _newNums;\n    // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    _capacity = _arr.length;\n  }\n\n  /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n  List<int> toArray() {\n    List<int> arr = [];\n    for (var i = 0; i < _size; i++) {\n      arr.add(get(i));\n    }\n    return arr;\n  }\n}\n
    my_list.rs
    /* \u5217\u8868\u7c7b */\n#[allow(dead_code)]\nstruct MyList {\n    arr: Vec<i32>,       // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    capacity: usize,     // \u5217\u8868\u5bb9\u91cf\n    size: usize,         // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    extend_ratio: usize, // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n}\n\n#[allow(unused, unused_comparisons)]\nimpl MyList {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(capacity: usize) -> Self {\n        let mut vec = Vec::new();\n        vec.resize(capacity, 0);\n        Self {\n            arr: vec,\n            capacity,\n            size: 0,\n            extend_ratio: 2,\n        }\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09*/\n    pub fn size(&self) -> usize {\n        return self.size;\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    pub fn capacity(&self) -> usize {\n        return self.capacity;\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    pub fn get(&self, index: usize) -> i32 {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if index >= self.size {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        return self.arr[index];\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    pub fn set(&mut self, index: usize, num: i32) {\n        if index >= self.size {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        self.arr[index] = num;\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    pub fn add(&mut self, num: i32) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        self.arr[self.size] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size += 1;\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    pub fn insert(&mut self, index: usize, num: i32) {\n        if index >= self.size() {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if self.size == self.capacity() {\n            self.extend_capacity();\n        }\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for j in (index..self.size).rev() {\n            self.arr[j + 1] = self.arr[j];\n        }\n        self.arr[index] = num;\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size += 1;\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    pub fn remove(&mut self, index: usize) -> i32 {\n        if index >= self.size() {\n            panic!(\"\u7d22\u5f15\u8d8a\u754c\")\n        };\n        let num = self.arr[index];\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for j in (index..self.size - 1) {\n            self.arr[j] = self.arr[j + 1];\n        }\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        self.size -= 1;\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num;\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    pub fn extend_capacity(&mut self) {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        let new_capacity = self.capacity * self.extend_ratio;\n        self.arr.resize(new_capacity, 0);\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        self.capacity = new_capacity;\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    pub fn to_array(&mut self) -> Vec<i32> {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        let mut arr = Vec::new();\n        for i in 0..self.size {\n            arr.push(self.get(i));\n        }\n        arr\n    }\n}\n
    my_list.c
    /* \u5217\u8868\u7c7b */\ntypedef struct {\n    int *arr;        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    int capacity;    // \u5217\u8868\u5bb9\u91cf\n    int size;        // \u5217\u8868\u5927\u5c0f\n    int extendRatio; // \u5217\u8868\u6bcf\u6b21\u6269\u5bb9\u7684\u500d\u6570\n} MyList;\n\n/* \u6784\u9020\u51fd\u6570 */\nMyList *newMyList() {\n    MyList *nums = malloc(sizeof(MyList));\n    nums->capacity = 10;\n    nums->arr = malloc(sizeof(int) * nums->capacity);\n    nums->size = 0;\n    nums->extendRatio = 2;\n    return nums;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delMyList(MyList *nums) {\n    free(nums->arr);\n    free(nums);\n}\n\n/* \u83b7\u53d6\u5217\u8868\u957f\u5ea6 */\nint size(MyList *nums) {\n    return nums->size;\n}\n\n/* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\nint capacity(MyList *nums) {\n    return nums->capacity;\n}\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nint get(MyList *nums, int index) {\n    assert(index >= 0 && index < nums->size);\n    return nums->arr[index];\n}\n\n/* \u66f4\u65b0\u5143\u7d20 */\nvoid set(MyList *nums, int index, int num) {\n    assert(index >= 0 && index < nums->size);\n    nums->arr[index] = num;\n}\n\n/* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\nvoid add(MyList *nums, int num) {\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // \u6269\u5bb9\n    }\n    nums->arr[size(nums)] = num;\n    nums->size++;\n}\n\n/* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\nvoid insert(MyList *nums, int index, int num) {\n    assert(index >= 0 && index < size(nums));\n    // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    if (size(nums) == capacity(nums)) {\n        extendCapacity(nums); // \u6269\u5bb9\n    }\n    for (int i = size(nums); i > index; --i) {\n        nums->arr[i] = nums->arr[i - 1];\n    }\n    nums->arr[index] = num;\n    nums->size++;\n}\n\n/* \u5220\u9664\u5143\u7d20 */\n// \u6ce8\u610f\uff1astdio.h \u5360\u7528\u4e86 remove \u5173\u952e\u8bcd\nint removeItem(MyList *nums, int index) {\n    assert(index >= 0 && index < size(nums));\n    int num = nums->arr[index];\n    for (int i = index; i < size(nums) - 1; i++) {\n        nums->arr[i] = nums->arr[i + 1];\n    }\n    nums->size--;\n    return num;\n}\n\n/* \u5217\u8868\u6269\u5bb9 */\nvoid extendCapacity(MyList *nums) {\n    // \u5148\u5206\u914d\u7a7a\u95f4\n    int newCapacity = capacity(nums) * nums->extendRatio;\n    int *extend = (int *)malloc(sizeof(int) * newCapacity);\n    int *temp = nums->arr;\n\n    // \u62f7\u8d1d\u65e7\u6570\u636e\u5230\u65b0\u6570\u636e\n    for (int i = 0; i < size(nums); i++)\n        extend[i] = nums->arr[i];\n\n    // \u91ca\u653e\u65e7\u6570\u636e\n    free(temp);\n\n    // \u66f4\u65b0\u65b0\u6570\u636e\n    nums->arr = extend;\n    nums->capacity = newCapacity;\n}\n\n/* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a Array \u7528\u4e8e\u6253\u5370 */\nint *toArray(MyList *nums) {\n    return nums->arr;\n}\n
    my_list.kt
    /* \u5217\u8868\u7c7b */\nclass MyList {\n    private var arr: IntArray = intArrayOf() // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n    private var capacity = 10 // \u5217\u8868\u5bb9\u91cf\n    private var size = 0 // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n    private var extendRatio = 2 // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        arr = IntArray(capacity)\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09 */\n    fun size(): Int {\n        return size\n    }\n\n    /* \u83b7\u53d6\u5217\u8868\u5bb9\u91cf */\n    fun capacity(): Int {\n        return capacity\n    }\n\n    /* \u8bbf\u95ee\u5143\u7d20 */\n    fun get(index: Int): Int {\n        // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException()\n        return arr[index]\n    }\n\n    /* \u66f4\u65b0\u5143\u7d20 */\n    fun set(index: Int, num: Int) {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        arr[index] = num\n    }\n\n    /* \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 */\n    fun add(num: Int) {\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity()\n        arr[size] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++\n    }\n\n    /* \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 */\n    fun insert(index: Int, num: Int) {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n        if (size == capacity())\n            extendCapacity()\n        // \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        for (j in size - 1 downTo index)\n            arr[j + 1] = arr[j]\n        arr[index] = num\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size++\n    }\n\n    /* \u5220\u9664\u5143\u7d20 */\n    fun remove(index: Int): Int {\n        if (index < 0 || index >= size)\n            throw IndexOutOfBoundsException(\"\u7d22\u5f15\u8d8a\u754c\")\n        val num: Int = arr[index]\n        // \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n        for (j in index..<size - 1)\n            arr[j] = arr[j + 1]\n        // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n        size--\n        // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n        return num\n    }\n\n    /* \u5217\u8868\u6269\u5bb9 */\n    fun extendCapacity() {\n        // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extendRatio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n        arr = arr.copyOf(capacity() * extendRatio)\n        // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n        capacity = arr.size\n    }\n\n    /* \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 */\n    fun toArray(): IntArray {\n        val size = size()\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val arr = IntArray(size)\n        for (i in 0..<size) {\n            arr[i] = get(i)\n        }\n        return arr\n    }\n}\n
    my_list.rb
    ### \u5217\u8868\u7c7b ###\nclass MyList\n  attr_reader :size       # \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n  attr_reader :capacity   # \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\n\n  ### \u6784\u9020\u65b9\u6cd5 ###\n  def initialize\n    @capacity = 10\n    @size = 0\n    @extend_ratio = 2\n    @arr = Array.new capacity\n  end\n\n  ### \u8bbf\u95ee\u5143\u7d20 ###\n  def get(index)\n    # \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    @arr[index]\n  end\n\n  ### \u8bbf\u95ee\u5143\u7d20 ###\n  def set(index, num)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    @arr[index] = num\n  end\n\n  ### \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20 ###\n  def add(num)\n    # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    extend_capacity if size == capacity\n    @arr[size] = num\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size += 1\n  end\n\n  ### \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20 ###\n  def insert(index, num)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n\n    # \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n    extend_capacity if size == capacity\n\n    # \u5c06\u7d22\u5f15 index \u4ee5\u53ca\u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    for j in (size - 1).downto(index)\n      @arr[j + 1] = @arr[j] \n    end\n    @arr[index] = num\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size += 1\n  end\n\n  ### \u5220\u9664\u5143\u7d20 ###\n  def remove(index)\n    raise IndexError, \"\u7d22\u5f15\u8d8a\u754c\" if index < 0 || index >= size\n    num = @arr[index]\n\n    # \u5c06\u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n    for j in index...size\n      @arr[j] = @arr[j + 1]\n    end\n\n    # \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n    @size -= 1\n\n    # \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n    num\n  end\n\n  ### \u5217\u8868\u6269\u5bb9 ###\n  def extend_capacity\n    # \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a\u539f\u6570\u7ec4 extend_ratio \u500d\u7684\u65b0\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))\n    # \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n    @capacity = arr.length\n  end\n\n  ### \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4 ###\n  def to_array\n    sz = size\n    # \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    arr = Array.new sz\n    for i in 0...sz\n      arr[i] = get i\n    end\n    arr\n  end\nend\n
    my_list.zig
    // \u5217\u8868\u7c7b\nfn MyList(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        arr: []T = undefined,                        // \u6570\u7ec4\uff08\u5b58\u50a8\u5217\u8868\u5143\u7d20\uff09\n        arrCapacity: usize = 10,                     // \u5217\u8868\u5bb9\u91cf\n        numSize: usize = 0,                           // \u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        extendRatio: usize = 2,                       // \u6bcf\u6b21\u5217\u8868\u6269\u5bb9\u7684\u500d\u6570\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined, // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u5217\u8868\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);\n            @memset(self.arr, @as(T, 0));\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u5217\u8868\u957f\u5ea6\uff08\u5f53\u524d\u5143\u7d20\u6570\u91cf\uff09\n        pub fn size(self: *Self) usize {\n            return self.numSize;\n        }\n\n        // \u83b7\u53d6\u5217\u8868\u5bb9\u91cf\n        pub fn capacity(self: *Self) usize {\n            return self.arrCapacity;\n        }\n\n        // \u8bbf\u95ee\u5143\u7d20\n        pub fn get(self: *Self, index: usize) T {\n            // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            return self.arr[index];\n        }  \n\n        // \u66f4\u65b0\u5143\u7d20\n        pub fn set(self: *Self, index: usize, num: T) void {\n            // \u7d22\u5f15\u5982\u679c\u8d8a\u754c\uff0c\u5219\u629b\u51fa\u5f02\u5e38\uff0c\u4e0b\u540c\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            self.arr[index] = num;\n        }  \n\n        // \u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\n        pub fn add(self: *Self, num: T) !void {\n            // \u5143\u7d20\u6570\u91cf\u8d85\u51fa\u5bb9\u91cf\u65f6\uff0c\u89e6\u53d1\u6269\u5bb9\u673a\u5236\n            if (self.size() == self.capacity()) try self.extendCapacity();\n            self.arr[self.size()] = num;\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize += 1;\n        }  \n\n        // \u5728\u4e2d\u95f4\u63d2\u5165\u5143\u7d20\n        pub fn insert(self: *Self, index: usize, num: T) !void {\n            if (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\n            if (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\n            var j = self.size() - 1;\n            while (j >= index) : (j -= 1) {\n                self.arr[j + 1] = self.arr[j];\n            }\n            self.arr[index] = num;\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize += 1;\n        }\n\n        // \u5220\u9664\u5143\u7d20\n        pub fn remove(self: *Self, index: usize) T {\n            if (index < 0 or index >= self.size()) @panic(\"\u7d22\u5f15\u8d8a\u754c\");\n            var num = self.arr[index];\n            // \u5c06\u7d22\u5f15 index \u4e4b\u540e\u7684\u5143\u7d20\u90fd\u5411\u524d\u79fb\u52a8\u4e00\u4f4d\n            var j = index;\n            while (j < self.size() - 1) : (j += 1) {\n                self.arr[j] = self.arr[j + 1];\n            }\n            // \u66f4\u65b0\u5143\u7d20\u6570\u91cf\n            self.numSize -= 1;\n            // \u8fd4\u56de\u88ab\u5220\u9664\u7684\u5143\u7d20\n            return num;\n        }\n\n        // \u5217\u8868\u6269\u5bb9\n        pub fn extendCapacity(self: *Self) !void {\n            // \u65b0\u5efa\u4e00\u4e2a\u957f\u5ea6\u4e3a size * extendRatio \u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u539f\u6570\u7ec4\u590d\u5236\u5230\u65b0\u6570\u7ec4\n            var newCapacity = self.capacity() * self.extendRatio;\n            var 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\n            std.mem.copy(T, extend, self.arr);\n            self.arr = extend;\n            // \u66f4\u65b0\u5217\u8868\u5bb9\u91cf\n            self.arrCapacity = newCapacity;\n        }\n\n        // \u5c06\u5217\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n            var arr = try self.mem_allocator.alloc(T, self.size());\n           @memset(arr, @as(T, 0));\n            for (arr, 0..) |*num, i| {\n                num.* = self.get(i);\n            }\n            return arr;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/","title":"4.4 \u00a0 \u5185\u5b58\u4e0e\u7f13\u5b58 *","text":"

    \u5728\u672c\u7ae0\u7684\u524d\u4e24\u8282\u4e2d\uff0c\u6211\u4eec\u63a2\u8ba8\u4e86\u6570\u7ec4\u548c\u94fe\u8868\u8fd9\u4e24\u79cd\u57fa\u7840\u4e14\u91cd\u8981\u7684\u6570\u636e\u7ed3\u6784\uff0c\u5b83\u4eec\u5206\u522b\u4ee3\u8868\u4e86\u201c\u8fde\u7eed\u5b58\u50a8\u201d\u548c\u201c\u5206\u6563\u5b58\u50a8\u201d\u4e24\u79cd\u7269\u7406\u7ed3\u6784\u3002

    \u5b9e\u9645\u4e0a\uff0c\u7269\u7406\u7ed3\u6784\u5728\u5f88\u5927\u7a0b\u5ea6\u4e0a\u51b3\u5b9a\u4e86\u7a0b\u5e8f\u5bf9\u5185\u5b58\u548c\u7f13\u5b58\u7684\u4f7f\u7528\u6548\u7387\uff0c\u8fdb\u800c\u5f71\u54cd\u7b97\u6cd5\u7a0b\u5e8f\u7684\u6574\u4f53\u6027\u80fd\u3002

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#441","title":"4.4.1 \u00a0 \u8ba1\u7b97\u673a\u5b58\u50a8\u8bbe\u5907","text":"

    \u8ba1\u7b97\u673a\u4e2d\u5305\u62ec\u4e09\u79cd\u7c7b\u578b\u7684\u5b58\u50a8\u8bbe\u5907\uff1a\u300c\u786c\u76d8 hard disk\u300d\u3001\u300c\u5185\u5b58 random-access memory, RAM\u300d\u3001\u300c\u7f13\u5b58 cache memory\u300d\u3002\u8868 4-2 \u5c55\u793a\u4e86\u5b83\u4eec\u5728\u8ba1\u7b97\u673a\u7cfb\u7edf\u4e2d\u7684\u4e0d\u540c\u89d2\u8272\u548c\u6027\u80fd\u7279\u70b9\u3002

    \u8868 4-2 \u00a0 \u8ba1\u7b97\u673a\u7684\u5b58\u50a8\u8bbe\u5907

    \u786c\u76d8 \u5185\u5b58 \u7f13\u5b58 \u7528\u9014 \u957f\u671f\u5b58\u50a8\u6570\u636e\uff0c\u5305\u62ec\u64cd\u4f5c\u7cfb\u7edf\u3001\u7a0b\u5e8f\u3001\u6587\u4ef6\u7b49 \u4e34\u65f6\u5b58\u50a8\u5f53\u524d\u8fd0\u884c\u7684\u7a0b\u5e8f\u548c\u6b63\u5728\u5904\u7406\u7684\u6570\u636e \u5b58\u50a8\u7ecf\u5e38\u8bbf\u95ee\u7684\u6570\u636e\u548c\u6307\u4ee4\uff0c\u51cf\u5c11 CPU \u8bbf\u95ee\u5185\u5b58\u7684\u6b21\u6570 \u6613\u5931\u6027 \u65ad\u7535\u540e\u6570\u636e\u4e0d\u4f1a\u4e22\u5931 \u65ad\u7535\u540e\u6570\u636e\u4f1a\u4e22\u5931 \u65ad\u7535\u540e\u6570\u636e\u4f1a\u4e22\u5931 \u5bb9\u91cf \u8f83\u5927\uff0cTB \u7ea7\u522b \u8f83\u5c0f\uff0cGB \u7ea7\u522b \u975e\u5e38\u5c0f\uff0cMB \u7ea7\u522b \u901f\u5ea6 \u8f83\u6162\uff0c\u51e0\u767e\u5230\u51e0\u5343 MB/s \u8f83\u5feb\uff0c\u51e0\u5341 GB/s \u975e\u5e38\u5feb\uff0c\u51e0\u5341\u5230\u51e0\u767e GB/s \u4ef7\u683c \u8f83\u4fbf\u5b9c\uff0c\u51e0\u6bdb\u5230\u51e0\u5143 / GB \u8f83\u8d35\uff0c\u51e0\u5341\u5230\u51e0\u767e\u5143 / GB \u975e\u5e38\u8d35\uff0c\u968f CPU \u6253\u5305\u8ba1\u4ef7

    \u6211\u4eec\u53ef\u4ee5\u5c06\u8ba1\u7b97\u673a\u5b58\u50a8\u7cfb\u7edf\u60f3\u8c61\u4e3a\u56fe 4-9 \u6240\u793a\u7684\u91d1\u5b57\u5854\u7ed3\u6784\u3002\u8d8a\u9760\u8fd1\u91d1\u5b57\u5854\u9876\u7aef\u7684\u5b58\u50a8\u8bbe\u5907\u7684\u901f\u5ea6\u8d8a\u5feb\u3001\u5bb9\u91cf\u8d8a\u5c0f\u3001\u6210\u672c\u8d8a\u9ad8\u3002\u8fd9\u79cd\u591a\u5c42\u7ea7\u7684\u8bbe\u8ba1\u5e76\u975e\u5076\u7136\uff0c\u800c\u662f\u8ba1\u7b97\u673a\u79d1\u5b66\u5bb6\u548c\u5de5\u7a0b\u5e08\u4eec\u7ecf\u8fc7\u6df1\u601d\u719f\u8651\u7684\u7ed3\u679c\u3002

    • \u786c\u76d8\u96be\u4ee5\u88ab\u5185\u5b58\u53d6\u4ee3\u3002\u9996\u5148\uff0c\u5185\u5b58\u4e2d\u7684\u6570\u636e\u5728\u65ad\u7535\u540e\u4f1a\u4e22\u5931\uff0c\u56e0\u6b64\u5b83\u4e0d\u9002\u5408\u957f\u671f\u5b58\u50a8\u6570\u636e\uff1b\u5176\u6b21\uff0c\u5185\u5b58\u7684\u6210\u672c\u662f\u786c\u76d8\u7684\u51e0\u5341\u500d\uff0c\u8fd9\u4f7f\u5f97\u5b83\u96be\u4ee5\u5728\u6d88\u8d39\u8005\u5e02\u573a\u666e\u53ca\u3002
    • \u7f13\u5b58\u7684\u5927\u5bb9\u91cf\u548c\u9ad8\u901f\u5ea6\u96be\u4ee5\u517c\u5f97\u3002\u968f\u7740 L1\u3001L2\u3001L3 \u7f13\u5b58\u7684\u5bb9\u91cf\u9010\u6b65\u589e\u5927\uff0c\u5176\u7269\u7406\u5c3a\u5bf8\u4f1a\u53d8\u5927\uff0c\u4e0e CPU \u6838\u5fc3\u4e4b\u95f4\u7684\u7269\u7406\u8ddd\u79bb\u4f1a\u53d8\u8fdc\uff0c\u4ece\u800c\u5bfc\u81f4\u6570\u636e\u4f20\u8f93\u65f6\u95f4\u589e\u52a0\uff0c\u5143\u7d20\u8bbf\u95ee\u5ef6\u8fdf\u53d8\u9ad8\u3002\u5728\u5f53\u524d\u6280\u672f\u4e0b\uff0c\u591a\u5c42\u7ea7\u7684\u7f13\u5b58\u7ed3\u6784\u662f\u5bb9\u91cf\u3001\u901f\u5ea6\u548c\u6210\u672c\u4e4b\u95f4\u7684\u6700\u4f73\u5e73\u8861\u70b9\u3002

    \u56fe 4-9 \u00a0 \u8ba1\u7b97\u673a\u5b58\u50a8\u7cfb\u7edf

    Note

    \u8ba1\u7b97\u673a\u7684\u5b58\u50a8\u5c42\u6b21\u7ed3\u6784\u4f53\u73b0\u4e86\u901f\u5ea6\u3001\u5bb9\u91cf\u548c\u6210\u672c\u4e09\u8005\u4e4b\u95f4\u7684\u7cbe\u5999\u5e73\u8861\u3002\u5b9e\u9645\u4e0a\uff0c\u8fd9\u79cd\u6743\u8861\u666e\u904d\u5b58\u5728\u4e8e\u6240\u6709\u5de5\u4e1a\u9886\u57df\uff0c\u5b83\u8981\u6c42\u6211\u4eec\u5728\u4e0d\u540c\u7684\u4f18\u52bf\u548c\u9650\u5236\u4e4b\u95f4\u627e\u5230\u6700\u4f73\u5e73\u8861\u70b9\u3002

    \u603b\u7684\u6765\u8bf4\uff0c\u786c\u76d8\u7528\u4e8e\u957f\u671f\u5b58\u50a8\u5927\u91cf\u6570\u636e\uff0c\u5185\u5b58\u7528\u4e8e\u4e34\u65f6\u5b58\u50a8\u7a0b\u5e8f\u8fd0\u884c\u4e2d\u6b63\u5728\u5904\u7406\u7684\u6570\u636e\uff0c\u800c\u7f13\u5b58\u5219\u7528\u4e8e\u5b58\u50a8\u7ecf\u5e38\u8bbf\u95ee\u7684\u6570\u636e\u548c\u6307\u4ee4\uff0c\u4ee5\u63d0\u9ad8\u7a0b\u5e8f\u8fd0\u884c\u6548\u7387\u3002\u4e09\u8005\u5171\u540c\u534f\u4f5c\uff0c\u786e\u4fdd\u8ba1\u7b97\u673a\u7cfb\u7edf\u9ad8\u6548\u8fd0\u884c\u3002

    \u5982\u56fe 4-10 \u6240\u793a\uff0c\u5728\u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u6570\u636e\u4f1a\u4ece\u786c\u76d8\u4e2d\u88ab\u8bfb\u53d6\u5230\u5185\u5b58\u4e2d\uff0c\u4f9b CPU \u8ba1\u7b97\u4f7f\u7528\u3002\u7f13\u5b58\u53ef\u4ee5\u770b\u4f5c CPU \u7684\u4e00\u90e8\u5206\uff0c\u5b83\u901a\u8fc7\u667a\u80fd\u5730\u4ece\u5185\u5b58\u52a0\u8f7d\u6570\u636e\uff0c\u7ed9 CPU \u63d0\u4f9b\u9ad8\u901f\u7684\u6570\u636e\u8bfb\u53d6\uff0c\u4ece\u800c\u663e\u8457\u63d0\u5347\u7a0b\u5e8f\u7684\u6267\u884c\u6548\u7387\uff0c\u51cf\u5c11\u5bf9\u8f83\u6162\u7684\u5185\u5b58\u7684\u4f9d\u8d56\u3002

    \u56fe 4-10 \u00a0 \u786c\u76d8\u3001\u5185\u5b58\u548c\u7f13\u5b58\u4e4b\u95f4\u7684\u6570\u636e\u6d41\u901a

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#442","title":"4.4.2 \u00a0 \u6570\u636e\u7ed3\u6784\u7684\u5185\u5b58\u6548\u7387","text":"

    \u5728\u5185\u5b58\u7a7a\u95f4\u5229\u7528\u65b9\u9762\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u5404\u81ea\u5177\u6709\u4f18\u52bf\u548c\u5c40\u9650\u6027\u3002

    \u4e00\u65b9\u9762\uff0c\u5185\u5b58\u662f\u6709\u9650\u7684\uff0c\u4e14\u540c\u4e00\u5757\u5185\u5b58\u4e0d\u80fd\u88ab\u591a\u4e2a\u7a0b\u5e8f\u5171\u4eab\uff0c\u56e0\u6b64\u6211\u4eec\u5e0c\u671b\u6570\u636e\u7ed3\u6784\u80fd\u591f\u5c3d\u53ef\u80fd\u9ad8\u6548\u5730\u5229\u7528\u7a7a\u95f4\u3002\u6570\u7ec4\u7684\u5143\u7d20\u7d27\u5bc6\u6392\u5217\uff0c\u4e0d\u9700\u8981\u989d\u5916\u7684\u7a7a\u95f4\u6765\u5b58\u50a8\u94fe\u8868\u8282\u70b9\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\uff0c\u56e0\u6b64\u7a7a\u95f4\u6548\u7387\u66f4\u9ad8\u3002\u7136\u800c\uff0c\u6570\u7ec4\u9700\u8981\u4e00\u6b21\u6027\u5206\u914d\u8db3\u591f\u7684\u8fde\u7eed\u5185\u5b58\u7a7a\u95f4\uff0c\u8fd9\u53ef\u80fd\u5bfc\u81f4\u5185\u5b58\u6d6a\u8d39\uff0c\u6570\u7ec4\u6269\u5bb9\u4e5f\u9700\u8981\u989d\u5916\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u6210\u672c\u3002\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u94fe\u8868\u4ee5\u201c\u8282\u70b9\u201d\u4e3a\u5355\u4f4d\u8fdb\u884c\u52a8\u6001\u5185\u5b58\u5206\u914d\u548c\u56de\u6536\uff0c\u63d0\u4f9b\u4e86\u66f4\u5927\u7684\u7075\u6d3b\u6027\u3002

    \u53e6\u4e00\u65b9\u9762\uff0c\u5728\u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u968f\u7740\u53cd\u590d\u7533\u8bf7\u4e0e\u91ca\u653e\u5185\u5b58\uff0c\u7a7a\u95f2\u5185\u5b58\u7684\u788e\u7247\u5316\u7a0b\u5ea6\u4f1a\u8d8a\u6765\u8d8a\u9ad8\uff0c\u4ece\u800c\u5bfc\u81f4\u5185\u5b58\u7684\u5229\u7528\u6548\u7387\u964d\u4f4e\u3002\u6570\u7ec4\u7531\u4e8e\u5176\u8fde\u7eed\u7684\u5b58\u50a8\u65b9\u5f0f\uff0c\u76f8\u5bf9\u4e0d\u5bb9\u6613\u5bfc\u81f4\u5185\u5b58\u788e\u7247\u5316\u3002\u76f8\u53cd\uff0c\u94fe\u8868\u7684\u5143\u7d20\u662f\u5206\u6563\u5b58\u50a8\u7684\uff0c\u5728\u9891\u7e41\u7684\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u4e2d\uff0c\u66f4\u5bb9\u6613\u5bfc\u81f4\u5185\u5b58\u788e\u7247\u5316\u3002

    "},{"location":"chapter_array_and_linkedlist/ram_and_cache/#443","title":"4.4.3 \u00a0 \u6570\u636e\u7ed3\u6784\u7684\u7f13\u5b58\u6548\u7387","text":"

    \u7f13\u5b58\u867d\u7136\u5728\u7a7a\u95f4\u5bb9\u91cf\u4e0a\u8fdc\u5c0f\u4e8e\u5185\u5b58\uff0c\u4f46\u5b83\u6bd4\u5185\u5b58\u5feb\u5f97\u591a\uff0c\u5728\u7a0b\u5e8f\u6267\u884c\u901f\u5ea6\u4e0a\u8d77\u7740\u81f3\u5173\u91cd\u8981\u7684\u4f5c\u7528\u3002\u7531\u4e8e\u7f13\u5b58\u7684\u5bb9\u91cf\u6709\u9650\uff0c\u53ea\u80fd\u5b58\u50a8\u4e00\u5c0f\u90e8\u5206\u9891\u7e41\u8bbf\u95ee\u7684\u6570\u636e\uff0c\u56e0\u6b64\u5f53 CPU \u5c1d\u8bd5\u8bbf\u95ee\u7684\u6570\u636e\u4e0d\u5728\u7f13\u5b58\u4e2d\u65f6\uff0c\u5c31\u4f1a\u53d1\u751f\u300c\u7f13\u5b58\u672a\u547d\u4e2d cache miss\u300d\uff0c\u6b64\u65f6 CPU \u4e0d\u5f97\u4e0d\u4ece\u901f\u5ea6\u8f83\u6162\u7684\u5185\u5b58\u4e2d\u52a0\u8f7d\u6240\u9700\u6570\u636e\u3002

    \u663e\u7136\uff0c\u201c\u7f13\u5b58\u672a\u547d\u4e2d\u201d\u8d8a\u5c11\uff0cCPU \u8bfb\u5199\u6570\u636e\u7684\u6548\u7387\u5c31\u8d8a\u9ad8\uff0c\u7a0b\u5e8f\u6027\u80fd\u4e5f\u5c31\u8d8a\u597d\u3002\u6211\u4eec\u5c06 CPU \u4ece\u7f13\u5b58\u4e2d\u6210\u529f\u83b7\u53d6\u6570\u636e\u7684\u6bd4\u4f8b\u79f0\u4e3a\u300c\u7f13\u5b58\u547d\u4e2d\u7387 cache hit rate\u300d\uff0c\u8fd9\u4e2a\u6307\u6807\u901a\u5e38\u7528\u6765\u8861\u91cf\u7f13\u5b58\u6548\u7387\u3002

    \u4e3a\u4e86\u5c3d\u53ef\u80fd\u8fbe\u5230\u66f4\u9ad8\u7684\u6548\u7387\uff0c\u7f13\u5b58\u4f1a\u91c7\u53d6\u4ee5\u4e0b\u6570\u636e\u52a0\u8f7d\u673a\u5236\u3002

    • \u7f13\u5b58\u884c\uff1a\u7f13\u5b58\u4e0d\u662f\u5355\u4e2a\u5b57\u8282\u5730\u5b58\u50a8\u4e0e\u52a0\u8f7d\u6570\u636e\uff0c\u800c\u662f\u4ee5\u7f13\u5b58\u884c\u4e3a\u5355\u4f4d\u3002\u76f8\u6bd4\u4e8e\u5355\u4e2a\u5b57\u8282\u7684\u4f20\u8f93\uff0c\u7f13\u5b58\u884c\u7684\u4f20\u8f93\u5f62\u5f0f\u66f4\u52a0\u9ad8\u6548\u3002
    • \u9884\u53d6\u673a\u5236\uff1a\u5904\u7406\u5668\u4f1a\u5c1d\u8bd5\u9884\u6d4b\u6570\u636e\u8bbf\u95ee\u6a21\u5f0f\uff08\u4f8b\u5982\u987a\u5e8f\u8bbf\u95ee\u3001\u56fa\u5b9a\u6b65\u957f\u8df3\u8dc3\u8bbf\u95ee\u7b49\uff09\uff0c\u5e76\u6839\u636e\u7279\u5b9a\u6a21\u5f0f\u5c06\u6570\u636e\u52a0\u8f7d\u81f3\u7f13\u5b58\u4e4b\u4e2d\uff0c\u4ece\u800c\u63d0\u5347\u547d\u4e2d\u7387\u3002
    • \u7a7a\u95f4\u5c40\u90e8\u6027\uff1a\u5982\u679c\u4e00\u4e2a\u6570\u636e\u88ab\u8bbf\u95ee\uff0c\u90a3\u4e48\u5b83\u9644\u8fd1\u7684\u6570\u636e\u53ef\u80fd\u8fd1\u671f\u4e5f\u4f1a\u88ab\u8bbf\u95ee\u3002\u56e0\u6b64\uff0c\u7f13\u5b58\u5728\u52a0\u8f7d\u67d0\u4e00\u6570\u636e\u65f6\uff0c\u4e5f\u4f1a\u52a0\u8f7d\u5176\u9644\u8fd1\u7684\u6570\u636e\uff0c\u4ee5\u63d0\u9ad8\u547d\u4e2d\u7387\u3002
    • \u65f6\u95f4\u5c40\u90e8\u6027\uff1a\u5982\u679c\u4e00\u4e2a\u6570\u636e\u88ab\u8bbf\u95ee\uff0c\u90a3\u4e48\u5b83\u5728\u4e0d\u4e45\u7684\u5c06\u6765\u5f88\u53ef\u80fd\u518d\u6b21\u88ab\u8bbf\u95ee\u3002\u7f13\u5b58\u5229\u7528\u8fd9\u4e00\u539f\u7406\uff0c\u901a\u8fc7\u4fdd\u7559\u6700\u8fd1\u8bbf\u95ee\u8fc7\u7684\u6570\u636e\u6765\u63d0\u9ad8\u547d\u4e2d\u7387\u3002

    \u5b9e\u9645\u4e0a\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u5bf9\u7f13\u5b58\u7684\u5229\u7528\u6548\u7387\u662f\u4e0d\u540c\u7684\uff0c\u4e3b\u8981\u4f53\u73b0\u5728\u4ee5\u4e0b\u51e0\u4e2a\u65b9\u9762\u3002

    • \u5360\u7528\u7a7a\u95f4\uff1a\u94fe\u8868\u5143\u7d20\u6bd4\u6570\u7ec4\u5143\u7d20\u5360\u7528\u7a7a\u95f4\u66f4\u591a\uff0c\u5bfc\u81f4\u7f13\u5b58\u4e2d\u5bb9\u7eb3\u7684\u6709\u6548\u6570\u636e\u91cf\u66f4\u5c11\u3002
    • \u7f13\u5b58\u884c\uff1a\u94fe\u8868\u6570\u636e\u5206\u6563\u5728\u5185\u5b58\u5404\u5904\uff0c\u800c\u7f13\u5b58\u662f\u201c\u6309\u884c\u52a0\u8f7d\u201d\u7684\uff0c\u56e0\u6b64\u52a0\u8f7d\u5230\u65e0\u6548\u6570\u636e\u7684\u6bd4\u4f8b\u66f4\u9ad8\u3002
    • \u9884\u53d6\u673a\u5236\uff1a\u6570\u7ec4\u6bd4\u94fe\u8868\u7684\u6570\u636e\u8bbf\u95ee\u6a21\u5f0f\u66f4\u5177\u201c\u53ef\u9884\u6d4b\u6027\u201d\uff0c\u5373\u7cfb\u7edf\u66f4\u5bb9\u6613\u731c\u51fa\u5373\u5c06\u88ab\u52a0\u8f7d\u7684\u6570\u636e\u3002
    • \u7a7a\u95f4\u5c40\u90e8\u6027\uff1a\u6570\u7ec4\u88ab\u5b58\u50a8\u5728\u96c6\u4e2d\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u56e0\u6b64\u88ab\u52a0\u8f7d\u6570\u636e\u9644\u8fd1\u7684\u6570\u636e\u66f4\u6709\u53ef\u80fd\u5373\u5c06\u88ab\u8bbf\u95ee\u3002

    \u603b\u4f53\u800c\u8a00\uff0c\u6570\u7ec4\u5177\u6709\u66f4\u9ad8\u7684\u7f13\u5b58\u547d\u4e2d\u7387\uff0c\u56e0\u6b64\u5b83\u5728\u64cd\u4f5c\u6548\u7387\u4e0a\u901a\u5e38\u4f18\u4e8e\u94fe\u8868\u3002\u8fd9\u4f7f\u5f97\u5728\u89e3\u51b3\u7b97\u6cd5\u95ee\u9898\u65f6\uff0c\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u5f80\u5f80\u66f4\u53d7\u6b22\u8fce\u3002

    \u9700\u8981\u6ce8\u610f\u7684\u662f\uff0c\u9ad8\u7f13\u5b58\u6548\u7387\u5e76\u4e0d\u610f\u5473\u7740\u6570\u7ec4\u5728\u6240\u6709\u60c5\u51b5\u4e0b\u90fd\u4f18\u4e8e\u94fe\u8868\u3002\u5b9e\u9645\u5e94\u7528\u4e2d\u9009\u62e9\u54ea\u79cd\u6570\u636e\u7ed3\u6784\uff0c\u5e94\u6839\u636e\u5177\u4f53\u9700\u6c42\u6765\u51b3\u5b9a\u3002\u4f8b\u5982\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u90fd\u53ef\u4ee5\u5b9e\u73b0\u201c\u6808\u201d\u6570\u636e\u7ed3\u6784\uff08\u4e0b\u4e00\u7ae0\u4f1a\u8be6\u7ec6\u4ecb\u7ecd\uff09\uff0c\u4f46\u5b83\u4eec\u9002\u7528\u4e8e\u4e0d\u540c\u573a\u666f\u3002

    • \u5728\u505a\u7b97\u6cd5\u9898\u65f6\uff0c\u6211\u4eec\u4f1a\u503e\u5411\u4e8e\u9009\u62e9\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\uff0c\u56e0\u4e3a\u5b83\u63d0\u4f9b\u4e86\u66f4\u9ad8\u7684\u64cd\u4f5c\u6548\u7387\u548c\u968f\u673a\u8bbf\u95ee\u7684\u80fd\u529b\uff0c\u4ee3\u4ef7\u4ec5\u662f\u9700\u8981\u9884\u5148\u4e3a\u6570\u7ec4\u5206\u914d\u4e00\u5b9a\u7684\u5185\u5b58\u7a7a\u95f4\u3002
    • \u5982\u679c\u6570\u636e\u91cf\u975e\u5e38\u5927\u3001\u52a8\u6001\u6027\u5f88\u9ad8\u3001\u6808\u7684\u9884\u671f\u5927\u5c0f\u96be\u4ee5\u4f30\u8ba1\uff0c\u90a3\u4e48\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\u66f4\u52a0\u5408\u9002\u3002\u94fe\u8868\u80fd\u591f\u5c06\u5927\u91cf\u6570\u636e\u5206\u6563\u5b58\u50a8\u4e8e\u5185\u5b58\u7684\u4e0d\u540c\u90e8\u5206\uff0c\u5e76\u4e14\u907f\u514d\u4e86\u6570\u7ec4\u6269\u5bb9\u4ea7\u751f\u7684\u989d\u5916\u5f00\u9500\u3002
    "},{"location":"chapter_array_and_linkedlist/summary/","title":"4.5 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_array_and_linkedlist/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","text":"
    • \u6570\u7ec4\u548c\u94fe\u8868\u662f\u4e24\u79cd\u57fa\u672c\u7684\u6570\u636e\u7ed3\u6784\uff0c\u5206\u522b\u4ee3\u8868\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u4e24\u79cd\u5b58\u50a8\u65b9\u5f0f\uff1a\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u548c\u5206\u6563\u7a7a\u95f4\u5b58\u50a8\u3002\u4e24\u8005\u7684\u7279\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\u5f15\u7528\uff08\u6307\u9488\uff09\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\u73af\u5f62\u94fe\u8868\u3001\u53cc\u5411\u94fe\u8868\u3002
    • \u5217\u8868\u662f\u4e00\u79cd\u652f\u6301\u589e\u5220\u67e5\u6539\u7684\u5143\u7d20\u6709\u5e8f\u96c6\u5408\uff0c\u901a\u5e38\u57fa\u4e8e\u52a8\u6001\u6570\u7ec4\u5b9e\u73b0\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\u5927\u5e45\u63d0\u9ad8\u4e86\u6570\u7ec4\u7684\u5b9e\u7528\u6027\uff0c\u4f46\u53ef\u80fd\u5bfc\u81f4\u90e8\u5206\u5185\u5b58\u7a7a\u95f4\u6d6a\u8d39\u3002
    • \u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u6570\u636e\u4e3b\u8981\u5b58\u50a8\u5728\u5185\u5b58\u4e2d\u3002\u6570\u7ec4\u53ef\u63d0\u4f9b\u66f4\u9ad8\u7684\u5185\u5b58\u7a7a\u95f4\u6548\u7387\uff0c\u800c\u94fe\u8868\u5219\u5728\u5185\u5b58\u4f7f\u7528\u4e0a\u66f4\u52a0\u7075\u6d3b\u3002
    • \u7f13\u5b58\u901a\u8fc7\u7f13\u5b58\u884c\u3001\u9884\u53d6\u673a\u5236\u4ee5\u53ca\u7a7a\u95f4\u5c40\u90e8\u6027\u548c\u65f6\u95f4\u5c40\u90e8\u6027\u7b49\u6570\u636e\u52a0\u8f7d\u673a\u5236\uff0c\u4e3a CPU \u63d0\u4f9b\u5feb\u901f\u6570\u636e\u8bbf\u95ee\uff0c\u663e\u8457\u63d0\u5347\u7a0b\u5e8f\u7684\u6267\u884c\u6548\u7387\u3002
    • \u7531\u4e8e\u6570\u7ec4\u5177\u6709\u66f4\u9ad8\u7684\u7f13\u5b58\u547d\u4e2d\u7387\uff0c\u56e0\u6b64\u5b83\u901a\u5e38\u6bd4\u94fe\u8868\u66f4\u9ad8\u6548\u3002\u5728\u9009\u62e9\u6570\u636e\u7ed3\u6784\u65f6\uff0c\u5e94\u6839\u636e\u5177\u4f53\u9700\u6c42\u548c\u573a\u666f\u505a\u51fa\u6070\u5f53\u9009\u62e9\u3002
    "},{"location":"chapter_array_and_linkedlist/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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

    \u5b58\u50a8\u5728\u6808\u4e0a\u548c\u5806\u4e0a\u7684\u6570\u7ec4\u90fd\u88ab\u5b58\u50a8\u5728\u8fde\u7eed\u5185\u5b58\u7a7a\u95f4\u5185\uff0c\u6570\u636e\u64cd\u4f5c\u6548\u7387\u57fa\u672c\u4e00\u81f4\u3002\u7136\u800c\uff0c\u6808\u548c\u5806\u5177\u6709\u5404\u81ea\u7684\u7279\u70b9\uff0c\u4ece\u800c\u5bfc\u81f4\u4ee5\u4e0b\u4e0d\u540c\u70b9\u3002

    1. \u5206\u914d\u548c\u91ca\u653e\u6548\u7387\uff1a\u6808\u662f\u4e00\u5757\u8f83\u5c0f\u7684\u5185\u5b58\uff0c\u5206\u914d\u7531\u7f16\u8bd1\u5668\u81ea\u52a8\u5b8c\u6210\uff1b\u800c\u5806\u5185\u5b58\u76f8\u5bf9\u66f4\u5927\uff0c\u53ef\u4ee5\u5728\u4ee3\u7801\u4e2d\u52a8\u6001\u5206\u914d\uff0c\u66f4\u5bb9\u6613\u788e\u7247\u5316\u3002\u56e0\u6b64\uff0c\u5806\u4e0a\u7684\u5206\u914d\u548c\u91ca\u653e\u64cd\u4f5c\u901a\u5e38\u6bd4\u6808\u4e0a\u7684\u6162\u3002
    2. \u5927\u5c0f\u9650\u5236\uff1a\u6808\u5185\u5b58\u76f8\u5bf9\u8f83\u5c0f\uff0c\u5806\u7684\u5927\u5c0f\u4e00\u822c\u53d7\u9650\u4e8e\u53ef\u7528\u5185\u5b58\u3002\u56e0\u6b64\u5806\u66f4\u52a0\u9002\u5408\u5b58\u50a8\u5927\u578b\u6570\u7ec4\u3002
    3. \u7075\u6d3b\u6027\uff1a\u6808\u4e0a\u7684\u6570\u7ec4\u7684\u5927\u5c0f\u9700\u8981\u5728\u7f16\u8bd1\u65f6\u786e\u5b9a\uff0c\u800c\u5806\u4e0a\u7684\u6570\u7ec4\u7684\u5927\u5c0f\u53ef\u4ee5\u5728\u8fd0\u884c\u65f6\u52a8\u6001\u786e\u5b9a\u3002

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

    \u94fe\u8868\u7531\u8282\u70b9\u7ec4\u6210\uff0c\u8282\u70b9\u4e4b\u95f4\u901a\u8fc7\u5f15\u7528\uff08\u6307\u9488\uff09\u8fde\u63a5\uff0c\u5404\u4e2a\u8282\u70b9\u53ef\u4ee5\u5b58\u50a8\u4e0d\u540c\u7c7b\u578b\u7684\u6570\u636e\uff0c\u4f8b\u5982 int\u3001double\u3001string\u3001object \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\u6570\u7ec4\u540c\u65f6\u5305\u542b int \u548c long \u4e24\u79cd\u7c7b\u578b\uff0c\u5355\u4e2a\u5143\u7d20\u5206\u522b\u5360\u7528 4 \u5b57\u8282 \u548c 8 \u5b57\u8282 \uff0c\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\u201c\u5143\u7d20\u957f\u5ea6\u201d\u3002

    # \u5143\u7d20\u5185\u5b58\u5730\u5740 = \u6570\u7ec4\u5185\u5b58\u5730\u5740\uff08\u9996\u5143\u7d20\u5185\u5b58\u5730\u5740\uff09 + \u5143\u7d20\u957f\u5ea6 * \u5143\u7d20\u7d22\u5f15\n

    Q\uff1a\u5220\u9664\u8282\u70b9 P \u540e\uff0c\u662f\u5426\u9700\u8981\u628a P.next \u8bbe\u4e3a None \u5462\uff1f

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

    \u4ece\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\uff08\u505a\u9898\uff09\u7684\u89d2\u5ea6\u770b\uff0c\u4e0d\u65ad\u5f00\u6ca1\u6709\u5173\u7cfb\uff0c\u53ea\u8981\u4fdd\u8bc1\u7a0b\u5e8f\u7684\u903b\u8f91\u662f\u6b63\u786e\u7684\u5c31\u884c\u3002\u4ece\u6807\u51c6\u5e93\u7684\u89d2\u5ea6\u770b\uff0c\u65ad\u5f00\u66f4\u52a0\u5b89\u5168\u3001\u903b\u8f91\u66f4\u52a0\u6e05\u6670\u3002\u5982\u679c\u4e0d\u65ad\u5f00\uff0c\u5047\u8bbe\u88ab\u5220\u9664\u8282\u70b9\u672a\u88ab\u6b63\u5e38\u56de\u6536\uff0c\u90a3\u4e48\u5b83\u4f1a\u5f71\u54cd\u540e\u7ee7\u8282\u70b9\u7684\u5185\u5b58\u56de\u6536\u3002

    Q\uff1a\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)\\) \u7684\u65f6\u95f4\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\u65f6\u95f4\u590d\u6742\u5ea6\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\u8282\u70b9\u3001\u5c3e\u8282\u70b9\uff0c\u6bcf\u6b21\u63d2\u5165\u4e0e\u5220\u9664\u64cd\u4f5c\u90fd\u662f \\(O(1)\\) \u3002

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

    \u8be5\u793a\u610f\u56fe\u53ea\u662f\u5b9a\u6027\u8868\u793a\uff0c\u5b9a\u91cf\u8868\u793a\u9700\u8981\u6839\u636e\u5177\u4f53\u60c5\u51b5\u8fdb\u884c\u5206\u6790\u3002

    • \u4e0d\u540c\u7c7b\u578b\u7684\u8282\u70b9\u503c\u5360\u7528\u7684\u7a7a\u95f4\u662f\u4e0d\u540c\u7684\uff0c\u6bd4\u5982 int\u3001long\u3001double \u548c\u5b9e\u4f8b\u5bf9\u8c61\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

    Q\uff1a\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

    Q\uff1a\u201c\u5217\u8868\u7684\u51fa\u73b0\u6781\u5927\u5730\u63d0\u9ad8\u4e86\u6570\u7ec4\u7684\u5b9e\u7528\u6027\uff0c\u4f46\u53ef\u80fd\u5bfc\u81f4\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\uff1b\u53e6\u4e00\u65b9\u9762\uff0c\u4e3a\u4e86\u9632\u6b62\u9891\u7e41\u6269\u5bb9\uff0c\u6269\u5bb9\u4e00\u822c\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

    Q\uff1a\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\u7684\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 5 \u4e2a\u8282\u70b9\u5bf9\u8c61\u4e5f\u5206\u6563\u5b58\u50a8\u5728\u5185\u5b58\u5404\u5904\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\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\uff0cPython \u4e2d\u7684\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\u65e0\u987b\u8fde\u7eed\u3002

    Q\uff1aC++ STL \u91cc\u9762\u7684 std::list \u5df2\u7ecf\u5b9e\u73b0\u4e86\u53cc\u5411\u94fe\u8868\uff0c\u4f46\u597d\u50cf\u4e00\u4e9b\u7b97\u6cd5\u4e66\u4e0a\u4e0d\u600e\u4e48\u76f4\u63a5\u4f7f\u7528\u5b83\uff0c\u662f\u4e0d\u662f\u56e0\u4e3a\u6709\u4ec0\u4e48\u5c40\u9650\u6027\u5462\uff1f

    \u4e00\u65b9\u9762\uff0c\u6211\u4eec\u5f80\u5f80\u66f4\u9752\u7750\u4f7f\u7528\u6570\u7ec4\u5b9e\u73b0\u7b97\u6cd5\uff0c\u800c\u53ea\u5728\u5fc5\u8981\u65f6\u624d\u4f7f\u7528\u94fe\u8868\uff0c\u4e3b\u8981\u6709\u4e24\u4e2a\u539f\u56e0\u3002

    • \u7a7a\u95f4\u5f00\u9500\uff1a\u7531\u4e8e\u6bcf\u4e2a\u5143\u7d20\u9700\u8981\u4e24\u4e2a\u989d\u5916\u7684\u6307\u9488\uff08\u4e00\u4e2a\u7528\u4e8e\u524d\u4e00\u4e2a\u5143\u7d20\uff0c\u4e00\u4e2a\u7528\u4e8e\u540e\u4e00\u4e2a\u5143\u7d20\uff09\uff0c\u6240\u4ee5 std::list \u901a\u5e38\u6bd4 std::vector \u66f4\u5360\u7528\u7a7a\u95f4\u3002
    • \u7f13\u5b58\u4e0d\u53cb\u597d\uff1a\u7531\u4e8e\u6570\u636e\u4e0d\u662f\u8fde\u7eed\u5b58\u653e\u7684\uff0c\u56e0\u6b64 std::list \u5bf9\u7f13\u5b58\u7684\u5229\u7528\u7387\u8f83\u4f4e\u3002\u4e00\u822c\u60c5\u51b5\u4e0b\uff0cstd::vector \u7684\u6027\u80fd\u4f1a\u66f4\u597d\u3002

    \u53e6\u4e00\u65b9\u9762\uff0c\u5fc5\u8981\u4f7f\u7528\u94fe\u8868\u7684\u60c5\u51b5\u4e3b\u8981\u662f\u4e8c\u53c9\u6811\u548c\u56fe\u3002\u6808\u548c\u961f\u5217\u5f80\u5f80\u4f1a\u4f7f\u7528\u7f16\u7a0b\u8bed\u8a00\u63d0\u4f9b\u7684 stack \u548c queue \uff0c\u800c\u975e\u94fe\u8868\u3002

    Q\uff1a\u521d\u59cb\u5316\u5217\u8868 res = [0] * self.size() \u64cd\u4f5c\uff0c\u4f1a\u5bfc\u81f4 res \u7684\u6bcf\u4e2a\u5143\u7d20\u5f15\u7528\u76f8\u540c\u7684\u5730\u5740\u5417\uff1f

    \u4e0d\u4f1a\u3002\u4f46\u4e8c\u7ef4\u6570\u7ec4\u4f1a\u6709\u8fd9\u4e2a\u95ee\u9898\uff0c\u4f8b\u5982\u521d\u59cb\u5316\u4e8c\u7ef4\u5217\u8868 res = [[0] * self.size()] \uff0c\u5219\u591a\u6b21\u5f15\u7528\u4e86\u540c\u4e00\u4e2a\u5217\u8868 [0] \u3002

    "},{"location":"chapter_backtracking/","title":"\u7b2c 13 \u7ae0 \u00a0 \u56de\u6eaf","text":"

    Abstract

    \u6211\u4eec\u5982\u540c\u8ff7\u5bab\u4e2d\u7684\u63a2\u7d22\u8005\uff0c\u5728\u524d\u8fdb\u7684\u9053\u8def\u4e0a\u53ef\u80fd\u4f1a\u9047\u5230\u56f0\u96be\u3002

    \u56de\u6eaf\u7684\u529b\u91cf\u8ba9\u6211\u4eec\u80fd\u591f\u91cd\u65b0\u5f00\u59cb\uff0c\u4e0d\u65ad\u5c1d\u8bd5\uff0c\u6700\u7ec8\u627e\u5230\u901a\u5f80\u5149\u660e\u7684\u51fa\u53e3\u3002

    "},{"location":"chapter_backtracking/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 13.1 \u00a0 \u56de\u6eaf\u7b97\u6cd5
    • 13.2 \u00a0 \u5168\u6392\u5217\u95ee\u9898
    • 13.3 \u00a0 \u5b50\u96c6\u548c\u95ee\u9898
    • 13.4 \u00a0 N \u7687\u540e\u95ee\u9898
    • 13.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_backtracking/backtracking_algorithm/","title":"13.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\u201c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u201d\u6765\u904d\u5386\u89e3\u7a7a\u95f4\u3002\u5728\u201c\u4e8c\u53c9\u6811\u201d\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\uff0c\u6211\u4eec\u5229\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\u68f5\u4e8c\u53c9\u6811\uff0c\u641c\u7d22\u5e76\u8bb0\u5f55\u6240\u6709\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\uff0c\u8bf7\u8fd4\u56de\u8282\u70b9\u5217\u8868\u3002

    \u5bf9\u4e8e\u6b64\u9898\uff0c\u6211\u4eec\u524d\u5e8f\u904d\u5386\u8fd9\u68f5\u6811\uff0c\u5e76\u5224\u65ad\u5f53\u524d\u8282\u70b9\u7684\u503c\u662f\u5426\u4e3a \\(7\\) \uff0c\u82e5\u662f\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u7684\u503c\u52a0\u5165\u7ed3\u679c\u5217\u8868 res \u4e4b\u4e2d\u3002\u76f8\u5173\u8fc7\u7a0b\u5b9e\u73b0\u5982\u56fe 13-1 \u548c\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig preorder_traversal_i_compact.py
    def pre_order(root: TreeNode):\n    \"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00\"\"\"\n    if root is None:\n        return\n    if root.val == 7:\n        # \u8bb0\u5f55\u89e3\n        res.append(root)\n    pre_order(root.left)\n    pre_order(root.right)\n
    preorder_traversal_i_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push_back(root);\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n}\n
    preorder_traversal_i_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.add(root);\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n}\n
    preorder_traversal_i_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.Add(root);\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n
    preorder_traversal_i_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunc preOrderI(root *TreeNode, res *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    if (root.Val).(int) == 7 {\n        // \u8bb0\u5f55\u89e3\n        *res = append(*res, root)\n    }\n    preOrderI(root.Left, res)\n    preOrderI(root.Right, res)\n}\n
    preorder_traversal_i_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    if root.val == 7 {\n        // \u8bb0\u5f55\u89e3\n        res.append(root)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n
    preorder_traversal_i_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfunction preOrder(root, res) {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(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 {\n    if (root === null) {\n        return;\n    }\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push(root);\n    }\n    preOrder(root.left, res);\n    preOrder(root.right, res);\n}\n
    preorder_traversal_i_compact.dart
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode? root, List<TreeNode> res) {\n  if (root == null) {\n    return;\n  }\n  if (root.val == 7) {\n    // \u8bb0\u5f55\u89e3\n    res.add(root);\n  }\n  preOrder(root.left, res);\n  preOrder(root.right, res);\n}\n
    preorder_traversal_i_compact.rs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfn pre_order(res: &mut Vec<Rc<RefCell<TreeNode>>>, root: Option<Rc<RefCell<TreeNode>>>) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        if node.borrow().val == 7 {\n            // \u8bb0\u5f55\u89e3\n            res.push(node.clone());\n        }\n        pre_order(res, node.borrow().left.clone());\n        pre_order(res, node.borrow().right.clone());\n    }\n}\n
    preorder_traversal_i_compact.c
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res[resSize++] = root;\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n}\n
    preorder_traversal_i_compact.kt
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e00 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    if (root.value == 7) {\n        // \u8bb0\u5f55\u89e3\n        res!!.add(root)\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n}\n
    preorder_traversal_i_compact.rb
    [class]{}-[func]{pre_order}\n
    preorder_traversal_i_compact.zig
    [class]{}-[func]{preOrder}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 13-1 \u00a0 \u5728\u524d\u5e8f\u904d\u5386\u4e2d\u641c\u7d22\u8282\u70b9

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1311","title":"13.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\u8282\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\u4ec5\u4ec5\u5305\u62ec\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\u8bf7\u8fd4\u56de\u6839\u8282\u70b9\u5230\u8fd9\u4e9b\u8282\u70b9\u7684\u8def\u5f84\u3002

    \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig preorder_traversal_ii_compact.py
    def pre_order(root: TreeNode):\n    \"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c\"\"\"\n    if root is None:\n        return\n    # \u5c1d\u8bd5\n    path.append(root)\n    if root.val == 7:\n        # \u8bb0\u5f55\u89e3\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # \u56de\u9000\n    path.pop()\n
    preorder_traversal_ii_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push_back(root);\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push_back(path);\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n    // \u56de\u9000\n    path.pop_back();\n}\n
    preorder_traversal_ii_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode root) {\n    if (root == null) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.add(root);\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.add(new ArrayList<>(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // \u56de\u9000\n    path.remove(path.size() - 1);\n}\n
    preorder_traversal_ii_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.Add(root);\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.Add(new List<TreeNode>(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // \u56de\u9000\n    path.RemoveAt(path.Count - 1);\n}\n
    preorder_traversal_ii_compact.go
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunc preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {\n    if root == nil {\n        return\n    }\n    // \u5c1d\u8bd5\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // \u8bb0\u5f55\u89e3\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderII(root.Left, res, path)\n    preOrderII(root.Right, res, path)\n    // \u56de\u9000\n    *path = (*path)[:len(*path)-1]\n}\n
    preorder_traversal_ii_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u5c1d\u8bd5\n    path.append(root)\n    if root.val == 7 {\n        // \u8bb0\u5f55\u89e3\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // \u56de\u9000\n    path.removeLast()\n}\n
    preorder_traversal_ii_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunction preOrder(root, path, res) {\n    if (root === null) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push(root);\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // \u56de\u9000\n    path.pop();\n}\n
    preorder_traversal_ii_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    if (root === null) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push(root);\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // \u56de\u9000\n    path.pop();\n}\n
    preorder_traversal_ii_compact.dart
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(\n  TreeNode? root,\n  List<TreeNode> path,\n  List<List<TreeNode>> res,\n) {\n  if (root == null) {\n    return;\n  }\n\n  // \u5c1d\u8bd5\n  path.add(root);\n  if (root.val == 7) {\n    // \u8bb0\u5f55\u89e3\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // \u56de\u9000\n  path.removeLast();\n}\n
    preorder_traversal_ii_compact.rs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfn pre_order(\n    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,\n    path: &mut Vec<Rc<RefCell<TreeNode>>>,\n    root: Option<Rc<RefCell<TreeNode>>>,\n) {\n    if root.is_none() {\n        return;\n    }\n    if let Some(node) = root {\n        // \u5c1d\u8bd5\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // \u8bb0\u5f55\u89e3\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.clone());\n        pre_order(res, path, node.borrow().right.clone());\n        // \u56de\u9000\n        path.remove(path.len() - 1);\n    }\n}\n
    preorder_traversal_ii_compact.c
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nvoid preOrder(TreeNode *root) {\n    if (root == NULL) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path[pathSize++] = root;\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        for (int i = 0; i < pathSize; ++i) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n    // \u56de\u9000\n    pathSize--;\n}\n
    preorder_traversal_ii_compact.kt
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e8c */\nfun preOrder(root: TreeNode?) {\n    if (root == null) {\n        return\n    }\n    // \u5c1d\u8bd5\n    path!!.add(root)\n    if (root.value == 7) {\n        // \u8bb0\u5f55\u89e3\n        res!!.add(ArrayList(path!!))\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // \u56de\u9000\n    path!!.removeAt(path!!.size - 1)\n}\n
    preorder_traversal_ii_compact.rb
    [class]{}-[func]{pre_order}\n
    preorder_traversal_ii_compact.zig
    [class]{}-[func]{preOrder}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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

    \u89c2\u5bdf\u56fe 13-2 \u6240\u793a\u7684\u8fc7\u7a0b\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\u4e92\u4e3a\u9006\u5411\u3002

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

    \u56fe 13-2 \u00a0 \u5c1d\u8bd5\u4e0e\u56de\u9000

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1312","title":"13.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\u8bf7\u8fd4\u56de\u6839\u8282\u70b9\u5230\u8fd9\u4e9b\u8282\u70b9\u7684\u8def\u5f84\uff0c\u5e76\u8981\u6c42\u8def\u5f84\u4e2d\u4e0d\u5305\u542b\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u3002

    \u4e3a\u4e86\u6ee1\u8db3\u4ee5\u4e0a\u7ea6\u675f\u6761\u4ef6\uff0c\u6211\u4eec\u9700\u8981\u6dfb\u52a0\u526a\u679d\u64cd\u4f5c\uff1a\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u82e5\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\uff0c\u5219\u63d0\u524d\u8fd4\u56de\uff0c\u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig preorder_traversal_iii_compact.py
    def pre_order(root: TreeNode):\n    \"\"\"\u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09\"\"\"\n    # \u526a\u679d\n    if root is None or root.val == 3:\n        return\n    # \u5c1d\u8bd5\n    path.append(root)\n    if root.val == 7:\n        # \u8bb0\u5f55\u89e3\n        res.append(list(path))\n    pre_order(root.left)\n    pre_order(root.right)\n    # \u56de\u9000\n    path.pop()\n
    preorder_traversal_iii_compact.cpp
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode *root) {\n    // \u526a\u679d\n    if (root == nullptr || root->val == 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push_back(root);\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push_back(path);\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n    // \u56de\u9000\n    path.pop_back();\n}\n
    preorder_traversal_iii_compact.java
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode root) {\n    // \u526a\u679d\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.add(root);\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.add(new ArrayList<>(path));\n    }\n    preOrder(root.left);\n    preOrder(root.right);\n    // \u56de\u9000\n    path.remove(path.size() - 1);\n}\n
    preorder_traversal_iii_compact.cs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid PreOrder(TreeNode? root) {\n    // \u526a\u679d\n    if (root == null || root.val == 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.Add(root);\n    if (root.val == 7) {\n        // \u8bb0\u5f55\u89e3\n        res.Add(new List<TreeNode>(path));\n    }\n    PreOrder(root.left);\n    PreOrder(root.right);\n    // \u56de\u9000\n    path.RemoveAt(path.Count - 1);\n}\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\n    if root == nil || root.Val == 3 {\n        return\n    }\n    // \u5c1d\u8bd5\n    *path = append(*path, root)\n    if root.Val.(int) == 7 {\n        // \u8bb0\u5f55\u89e3\n        *res = append(*res, append([]*TreeNode{}, *path...))\n    }\n    preOrderIII(root.Left, res, path)\n    preOrderIII(root.Right, res, path)\n    // \u56de\u9000\n    *path = (*path)[:len(*path)-1]\n}\n
    preorder_traversal_iii_compact.swift
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunc preOrder(root: TreeNode?) {\n    // \u526a\u679d\n    guard let root = root, root.val != 3 else {\n        return\n    }\n    // \u5c1d\u8bd5\n    path.append(root)\n    if root.val == 7 {\n        // \u8bb0\u5f55\u89e3\n        res.append(path)\n    }\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n    // \u56de\u9000\n    path.removeLast()\n}\n
    preorder_traversal_iii_compact.js
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunction preOrder(root, path, res) {\n    // \u526a\u679d\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push(root);\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // \u56de\u9000\n    path.pop();\n}\n
    preorder_traversal_iii_compact.ts
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfunction preOrder(\n    root: TreeNode | null,\n    path: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // \u526a\u679d\n    if (root === null || root.val === 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path.push(root);\n    if (root.val === 7) {\n        // \u8bb0\u5f55\u89e3\n        res.push([...path]);\n    }\n    preOrder(root.left, path, res);\n    preOrder(root.right, path, res);\n    // \u56de\u9000\n    path.pop();\n}\n
    preorder_traversal_iii_compact.dart
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(\n  TreeNode? root,\n  List<TreeNode> path,\n  List<List<TreeNode>> res,\n) {\n  if (root == null || root.val == 3) {\n    return;\n  }\n\n  // \u5c1d\u8bd5\n  path.add(root);\n  if (root.val == 7) {\n    // \u8bb0\u5f55\u89e3\n    res.add(List.from(path));\n  }\n  preOrder(root.left, path, res);\n  preOrder(root.right, path, res);\n  // \u56de\u9000\n  path.removeLast();\n}\n
    preorder_traversal_iii_compact.rs
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfn pre_order(\n    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,\n    path: &mut Vec<Rc<RefCell<TreeNode>>>,\n    root: Option<Rc<RefCell<TreeNode>>>,\n) {\n    // \u526a\u679d\n    if root.is_none() || root.as_ref().unwrap().borrow().val == 3 {\n        return;\n    }\n    if let Some(node) = root {\n        // \u5c1d\u8bd5\n        path.push(node.clone());\n        if node.borrow().val == 7 {\n            // \u8bb0\u5f55\u89e3\n            res.push(path.clone());\n        }\n        pre_order(res, path, node.borrow().left.clone());\n        pre_order(res, path, node.borrow().right.clone());\n        // \u56de\u9000\n        path.remove(path.len() - 1);\n    }\n}\n
    preorder_traversal_iii_compact.c
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nvoid preOrder(TreeNode *root) {\n    // \u526a\u679d\n    if (root == NULL || root->val == 3) {\n        return;\n    }\n    // \u5c1d\u8bd5\n    path[pathSize++] = root;\n    if (root->val == 7) {\n        // \u8bb0\u5f55\u89e3\n        for (int i = 0; i < pathSize; i++) {\n            res[resSize][i] = path[i];\n        }\n        resSize++;\n    }\n    preOrder(root->left);\n    preOrder(root->right);\n    // \u56de\u9000\n    pathSize--;\n}\n
    preorder_traversal_iii_compact.kt
    /* \u524d\u5e8f\u904d\u5386\uff1a\u4f8b\u9898\u4e09 */\nfun preOrder(root: TreeNode?) {\n    // \u526a\u679d\n    if (root == null || root.value == 3) {\n        return\n    }\n    // \u5c1d\u8bd5\n    path!!.add(root)\n    if (root.value == 7) {\n        // \u8bb0\u5f55\u89e3\n        res!!.add(ArrayList(path!!))\n    }\n    preOrder(root.left)\n    preOrder(root.right)\n    // \u56de\u9000\n    path!!.removeAt(path!!.size - 1)\n}\n
    preorder_traversal_iii_compact.rb
    [class]{}-[func]{pre_order}\n
    preorder_traversal_iii_compact.zig
    [class]{}-[func]{preOrder}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u201c\u526a\u679d\u201d\u662f\u4e00\u4e2a\u975e\u5e38\u5f62\u8c61\u7684\u540d\u8bcd\u3002\u5982\u56fe 13-3 \u6240\u793a\uff0c\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6211\u4eec\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\u9ad8\u4e86\u641c\u7d22\u6548\u7387\u3002

    \u56fe 13-3 \u00a0 \u6839\u636e\u7ea6\u675f\u6761\u4ef6\u526a\u679d

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1313","title":"13.1.3 \u00a0 \u6846\u67b6\u4ee3\u7801","text":"

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c1d\u8bd5\u5c06\u56de\u6eaf\u7684\u201c\u5c1d\u8bd5\u3001\u56de\u9000\u3001\u526a\u679d\u201d\u7684\u4e3b\u4f53\u6846\u67b6\u63d0\u70bc\u51fa\u6765\uff0c\u63d0\u5347\u4ee3\u7801\u7684\u901a\u7528\u6027\u3002

    \u5728\u4ee5\u4e0b\u6846\u67b6\u4ee3\u7801\u4e2d\uff0cstate \u8868\u793a\u95ee\u9898\u7684\u5f53\u524d\u72b6\u6001\uff0cchoices \u8868\u793a\u5f53\u524d\u72b6\u6001\u4e0b\u53ef\u4ee5\u505a\u51fa\u7684\u9009\u62e9\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def backtrack(state: State, choices: list[choice], res: list[state]):\n    \"\"\"\u56de\u6eaf\u7b97\u6cd5\u6846\u67b6\"\"\"\n    # \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if is_solution(state):\n        # \u8bb0\u5f55\u89e3\n        record_solution(state, res)\n        # \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices:\n        # \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if is_valid(state, choice):\n            # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            make_choice(state, choice)\n            backtrack(state, choices, res)\n            # \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undo_choice(state, choice)\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nvoid backtrack(State *state, vector<Choice *> &choices, vector<State *> &res) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (Choice choice : choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice);\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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (Choice choice : choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice);\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\n    if (IsSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        RecordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    foreach (Choice choice in choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (IsValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            MakeChoice(state, choice);\n            Backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            UndoChoice(state, choice);\n        }\n    }\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunc backtrack(state *State, choices []Choice, res *[]State) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if isSolution(state) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res)\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for _, choice := range choices {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if isValid(state, choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(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\n    if isSolution(state: state) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state: state, res: &res)\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if isValid(state: state, choice: choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state: &state, choice: choice)\n            backtrack(state: &state, choices: choices, res: &res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state: &state, choice: choice)\n        }\n    }\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfunction backtrack(state, choices, res) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (let choice of choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (let choice of choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice);\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\n  if (isSolution(state)) {\n    // \u8bb0\u5f55\u89e3\n    recordSolution(state, res);\n    // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (Choice choice in choices) {\n    // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n    if (isValid(state, choice)) {\n      // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n      makeChoice(state, choice);\n      backtrack(state, choices, res);\n      // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n      undoChoice(state, choice);\n    }\n  }\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfn backtrack(state: &mut State, choices: &Vec<Choice>, res: &mut Vec<State>) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if is_solution(state) {\n        // \u8bb0\u5f55\u89e3\n        record_solution(state, res);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if is_valid(state, choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            make_choice(state, choice);\n            backtrack(state, choices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undo_choice(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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res, numRes);\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < numChoices; i++) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, &choices[i])) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, &choices[i]);\n            backtrack(state, choices, numChoices, res, numRes);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, &choices[i]);\n        }\n    }\n}\n
    /* \u56de\u6eaf\u7b97\u6cd5\u6846\u67b6 */\nfun backtrack(state: State?, choices: List<Choice?>, res: List<State?>?) {\n    // \u5224\u65ad\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res)\n        // \u4e0d\u518d\u7ee7\u7eed\u641c\u7d22\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (choice in choices) {\n        // \u526a\u679d\uff1a\u5224\u65ad\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice)\n            backtrack(state, choices, res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice)\n        }\n    }\n}\n
    \n
    \n

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u57fa\u4e8e\u6846\u67b6\u4ee3\u7801\u6765\u89e3\u51b3\u4f8b\u9898\u4e09\u3002\u72b6\u6001 state \u4e3a\u8282\u70b9\u904d\u5386\u8def\u5f84\uff0c\u9009\u62e9 choices \u4e3a\u5f53\u524d\u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u548c\u53f3\u5b50\u8282\u70b9\uff0c\u7ed3\u679c res \u662f\u8def\u5f84\u5217\u8868\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig preorder_traversal_iii_template.py
    def is_solution(state: list[TreeNode]) -> bool:\n    \"\"\"\u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3\"\"\"\n    return state and state[-1].val == 7\n\ndef record_solution(state: list[TreeNode], res: list[list[TreeNode]]):\n    \"\"\"\u8bb0\u5f55\u89e3\"\"\"\n    res.append(list(state))\n\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\"\"\"\n    return choice is not None and choice.val != 3\n\ndef make_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"\u66f4\u65b0\u72b6\u6001\"\"\"\n    state.append(choice)\n\ndef undo_choice(state: list[TreeNode], choice: TreeNode):\n    \"\"\"\u6062\u590d\u72b6\u6001\"\"\"\n    state.pop()\n\ndef backtrack(\n    state: 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\n    if is_solution(state):\n        # \u8bb0\u5f55\u89e3\n        record_solution(state, res)\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices:\n        # \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if is_valid(state, choice):\n            # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            make_choice(state, choice)\n            # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, [choice.left, choice.right], res)\n            # \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undo_choice(state, choice)\n
    preorder_traversal_iii_template.cpp
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(vector<TreeNode *> &state) {\n    return !state.empty() && state.back()->val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res) {\n    res.push_back(state);\n}\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) {\n    return choice != nullptr && choice->val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(vector<TreeNode *> &state, TreeNode *choice) {\n    state.push_back(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(vector<TreeNode *> &state, TreeNode *choice) {\n    state.pop_back();\n}\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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (TreeNode *choice : choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            vector<TreeNode *> nextChoices{choice->left, choice->right};\n            backtrack(state, nextChoices, res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice);\n        }\n    }\n}\n
    preorder_traversal_iii_template.java
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nboolean isSolution(List<TreeNode> state) {\n    return !state.isEmpty() && state.get(state.size() - 1).val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\n    res.add(new ArrayList<>(state));\n}\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) {\n    return choice != null && choice.val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(List<TreeNode> state, TreeNode choice) {\n    state.add(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(List<TreeNode> state, TreeNode choice) {\n    state.remove(state.size() - 1);\n}\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\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (TreeNode choice : choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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\n            undoChoice(state, choice);\n        }\n    }\n}\n
    preorder_traversal_iii_template.cs
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool IsSolution(List<TreeNode> state) {\n    return state.Count != 0 && state[^1].val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid RecordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\n    res.Add(new List<TreeNode>(state));\n}\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) {\n    return choice != null && choice.val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid MakeChoice(List<TreeNode> state, TreeNode choice) {\n    state.Add(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid UndoChoice(List<TreeNode> state, TreeNode choice) {\n    state.RemoveAt(state.Count - 1);\n}\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\n    if (IsSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        RecordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    foreach (TreeNode choice in choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (IsValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            MakeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            Backtrack(state, [choice.left!, choice.right!], res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            UndoChoice(state, choice);\n        }\n    }\n}\n
    preorder_traversal_iii_template.go
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunc isSolution(state *[]*TreeNode) bool {\n    return len(*state) != 0 && (*state)[len(*state)-1].Val == 7\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfunc recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {\n    *res = append(*res, append([]*TreeNode{}, *state...))\n}\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 {\n    return choice != nil && choice.Val != 3\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfunc makeChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = append(*state, choice)\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfunc undoChoice(state *[]*TreeNode, choice *TreeNode) {\n    *state = (*state)[:len(*state)-1]\n}\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\n    if isSolution(state) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for _, choice := range *choices {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if isValid(state, choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            temp := make([]*TreeNode, 0)\n            temp = append(temp, choice.Left, choice.Right)\n            backtrackIII(state, &temp, res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(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\n/* \u8bb0\u5f55\u89e3 */\nfunc recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {\n    res.append(state)\n}\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 {\n    choice != nil && choice!.val != 3\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfunc makeChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.append(choice)\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfunc undoChoice(state: inout [TreeNode], choice: TreeNode) {\n    state.removeLast()\n}\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\n    if isSolution(state: state) {\n        recordSolution(state: state, res: &res)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if isValid(state: state, choice: choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state: &state, choice: choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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\n            undoChoice(state: &state, choice: choice)\n        }\n    }\n}\n
    preorder_traversal_iii_template.js
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfunction isSolution(state) {\n    return state && state[state.length - 1]?.val === 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfunction recordSolution(state, res) {\n    res.push([...state]);\n}\n\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfunction isValid(state, choice) {\n    return choice !== null && choice.val !== 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfunction makeChoice(state, choice) {\n    state.push(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfunction undoChoice(state) {\n    state.pop();\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunction backtrack(state, choices, res) {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (const choice of choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, [choice.left, choice.right], res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(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 {\n    return state && state[state.length - 1]?.val === 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfunction recordSolution(state: TreeNode[], res: TreeNode[][]): void {\n    res.push([...state]);\n}\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 {\n    return choice !== null && choice.val !== 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfunction makeChoice(state: TreeNode[], choice: TreeNode): void {\n    state.push(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfunction undoChoice(state: TreeNode[]): void {\n    state.pop();\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfunction backtrack(\n    state: TreeNode[],\n    choices: TreeNode[],\n    res: TreeNode[][]\n): void {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (const choice of choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, [choice.left, choice.right], res);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state);\n        }\n    }\n}\n
    preorder_traversal_iii_template.dart
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(List<TreeNode> state) {\n  return state.isNotEmpty && state.last.val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {\n  res.add(List.from(state));\n}\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) {\n  return choice != null && choice.val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(List<TreeNode> state, TreeNode? choice) {\n  state.add(choice!);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(List<TreeNode> state, TreeNode? choice) {\n  state.removeLast();\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(\n  List<TreeNode> state,\n  List<TreeNode?> choices,\n  List<List<TreeNode>> res,\n) {\n  // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n  if (isSolution(state)) {\n    // \u8bb0\u5f55\u89e3\n    recordSolution(state, res);\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (TreeNode? choice in choices) {\n    // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n    if (isValid(state, choice)) {\n      // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n      makeChoice(state, choice);\n      // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n      backtrack(state, [choice!.left, choice.right], res);\n      // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n      undoChoice(state, choice);\n    }\n  }\n}\n
    preorder_traversal_iii_template.rs
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfn is_solution(state: &mut Vec<Rc<RefCell<TreeNode>>>) -> bool {\n    return !state.is_empty() && state.get(state.len() - 1).unwrap().borrow().val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfn record_solution(\n    state: &mut Vec<Rc<RefCell<TreeNode>>>,\n    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,\n) {\n    res.push(state.clone());\n}\n\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfn is_valid(_: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) -> bool {\n    return choice.borrow().val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfn make_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, choice: Rc<RefCell<TreeNode>>) {\n    state.push(choice);\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfn undo_choice(state: &mut Vec<Rc<RefCell<TreeNode>>>, _: Rc<RefCell<TreeNode>>) {\n    state.remove(state.len() - 1);\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfn backtrack(\n    state: &mut Vec<Rc<RefCell<TreeNode>>>,\n    choices: &mut Vec<Rc<RefCell<TreeNode>>>,\n    res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>,\n) {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if is_solution(state) {\n        // \u8bb0\u5f55\u89e3\n        record_solution(state, res);\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if is_valid(state, choice.clone()) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            make_choice(state, choice.clone());\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(\n                state,\n                &mut vec![\n                    choice.borrow().left.clone().unwrap(),\n                    choice.borrow().right.clone().unwrap(),\n                ],\n                res,\n            );\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undo_choice(state, choice.clone());\n        }\n    }\n}\n
    preorder_traversal_iii_template.c
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nbool isSolution(void) {\n    return pathSize > 0 && path[pathSize - 1]->val == 7;\n}\n\n/* \u8bb0\u5f55\u89e3 */\nvoid recordSolution(void) {\n    for (int i = 0; i < pathSize; i++) {\n        res[resSize][i] = path[i];\n    }\n    resSize++;\n}\n\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nbool isValid(TreeNode *choice) {\n    return choice != NULL && choice->val != 3;\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nvoid makeChoice(TreeNode *choice) {\n    path[pathSize++] = choice;\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nvoid undoChoice(void) {\n    pathSize--;\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nvoid backtrack(TreeNode *choices[2]) {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if (isSolution()) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution();\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < 2; i++) {\n        TreeNode *choice = choices[i];\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            TreeNode *nextChoices[2] = {choice->left, choice->right};\n            backtrack(nextChoices);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice();\n        }\n    }\n}\n
    preorder_traversal_iii_template.kt
    /* \u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u5426\u4e3a\u89e3 */\nfun isSolution(state: List<TreeNode?>): Boolean {\n    return state.isNotEmpty() && state[state.size - 1]?.value == 7\n}\n\n/* \u8bb0\u5f55\u89e3 */\nfun recordSolution(state: MutableList<TreeNode?>?, res: MutableList<List<TreeNode?>?>) {\n    res.add(state?.let { ArrayList(it) })\n}\n\n/* \u5224\u65ad\u5728\u5f53\u524d\u72b6\u6001\u4e0b\uff0c\u8be5\u9009\u62e9\u662f\u5426\u5408\u6cd5 */\nfun isValid(state: List<TreeNode?>?, choice: TreeNode?): Boolean {\n    return choice != null && choice.value != 3\n}\n\n/* \u66f4\u65b0\u72b6\u6001 */\nfun makeChoice(state: MutableList<TreeNode?>, choice: TreeNode?) {\n    state.add(choice)\n}\n\n/* \u6062\u590d\u72b6\u6001 */\nfun undoChoice(state: MutableList<TreeNode?>, choice: TreeNode?) {\n    state.removeLast()\n}\n\n/* \u56de\u6eaf\u7b97\u6cd5\uff1a\u4f8b\u9898\u4e09 */\nfun backtrack(\n    state: MutableList<TreeNode?>,\n    choices: List<TreeNode?>,\n    res: MutableList<List<TreeNode?>?>\n) {\n    // \u68c0\u67e5\u662f\u5426\u4e3a\u89e3\n    if (isSolution(state)) {\n        // \u8bb0\u5f55\u89e3\n        recordSolution(state, res)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (choice in choices) {\n        // \u526a\u679d\uff1a\u68c0\u67e5\u9009\u62e9\u662f\u5426\u5408\u6cd5\n        if (isValid(state, choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            makeChoice(state, choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, listOf(choice!!.left, choice.right), res)\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            undoChoice(state, choice)\n        }\n    }\n}\n
    preorder_traversal_iii_template.rb
    [class]{}-[func]{is_solution}\n\n[class]{}-[func]{record_solution}\n\n[class]{}-[func]{is_valid}\n\n[class]{}-[func]{make_choice}\n\n[class]{}-[func]{undo_choice}\n\n[class]{}-[func]{backtrack}\n
    preorder_traversal_iii_template.zig
    [class]{}-[func]{isSolution}\n\n[class]{}-[func]{recordSolution}\n\n[class]{}-[func]{isValid}\n\n[class]{}-[func]{makeChoice}\n\n[class]{}-[func]{undoChoice}\n\n[class]{}-[func]{backtrack}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6839\u636e\u9898\u610f\uff0c\u6211\u4eec\u5728\u627e\u5230\u503c\u4e3a \\(7\\) \u7684\u8282\u70b9\u540e\u5e94\u8be5\u7ee7\u7eed\u641c\u7d22\uff0c\u56e0\u6b64\u9700\u8981\u5c06\u8bb0\u5f55\u89e3\u4e4b\u540e\u7684 return \u8bed\u53e5\u5220\u9664\u3002\u56fe 13-4 \u5bf9\u6bd4\u4e86\u4fdd\u7559\u6216\u5220\u9664 return \u8bed\u53e5\u7684\u641c\u7d22\u8fc7\u7a0b\u3002

    \u56fe 13-4 \u00a0 \u4fdd\u7559\u4e0e\u5220\u9664 return \u7684\u641c\u7d22\u8fc7\u7a0b\u5bf9\u6bd4

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

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1314","title":"13.1.4 \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\uff0c\u5982\u8868 13-1 \u6240\u793a\u3002

    \u8868 13-1 \u00a0 \u5e38\u89c1\u7684\u56de\u6eaf\u7b97\u6cd5\u672f\u8bed

    \u540d\u8bcd \u5b9a\u4e49 \u4f8b\u9898\u4e09 \u89e3\uff08solution\uff09 \u89e3\u662f\u6ee1\u8db3\u95ee\u9898\u7279\u5b9a\u6761\u4ef6\u7684\u7b54\u6848\uff0c\u53ef\u80fd\u6709\u4e00\u4e2a\u6216\u591a\u4e2a \u6839\u8282\u70b9\u5230\u8282\u70b9 \\(7\\) \u7684\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\u7684\u6240\u6709\u8def\u5f84 \u7ea6\u675f\u6761\u4ef6\uff08constraint\uff09 \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 \u8def\u5f84\u4e2d\u4e0d\u5305\u542b\u8282\u70b9 \\(3\\) \u72b6\u6001\uff08state\uff09 \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 \u5c1d\u8bd5\uff08attempt\uff09 \u5c1d\u8bd5\u662f\u6839\u636e\u53ef\u7528\u9009\u62e9\u6765\u63a2\u7d22\u89e3\u7a7a\u95f4\u7684\u8fc7\u7a0b\uff0c\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\uff08backtracking\uff09 \u56de\u9000\u6307\u9047\u5230\u4e0d\u6ee1\u8db3\u7ea6\u675f\u6761\u4ef6\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\u8282\u70b9\u3001\u7ed3\u675f\u8282\u70b9\u8bbf\u95ee\u3001\u9047\u5230\u503c\u4e3a \\(3\\) \u7684\u8282\u70b9\u65f6\u7ec8\u6b62\u641c\u7d22\uff0c\u51fd\u6570\u8fd4\u56de \u526a\u679d\uff08pruning\uff09 \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\u4e0d\u518d\u7ee7\u7eed\u641c\u7d22

    Tip

    \u95ee\u9898\u3001\u89e3\u3001\u72b6\u6001\u7b49\u6982\u5ff5\u662f\u901a\u7528\u7684\uff0c\u5728\u5206\u6cbb\u3001\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\u3001\u8d2a\u5fc3\u7b49\u7b97\u6cd5\u4e2d\u90fd\u6709\u6d89\u53ca\u3002

    "},{"location":"chapter_backtracking/backtracking_algorithm/#1315","title":"13.1.5 \u00a0 \u4f18\u70b9\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\u70b9\u5728\u4e8e\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

    • \u65f6\u95f4\uff1a\u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u9700\u8981\u904d\u5386\u72b6\u6001\u7a7a\u95f4\u7684\u6240\u6709\u53ef\u80fd\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u8fbe\u5230\u6307\u6570\u9636\u6216\u9636\u4e58\u9636\u3002
    • \u7a7a\u95f4\uff1a\u5728\u9012\u5f52\u8c03\u7528\u4e2d\u9700\u8981\u4fdd\u5b58\u5f53\u524d\u7684\u72b6\u6001\uff08\u4f8b\u5982\u8def\u5f84\u3001\u7528\u4e8e\u526a\u679d\u7684\u8f85\u52a9\u53d8\u91cf\u7b49\uff09\uff0c\u5f53\u6df1\u5ea6\u5f88\u5927\u65f6\uff0c\u7a7a\u95f4\u9700\u6c42\u53ef\u80fd\u4f1a\u53d8\u5f97\u5f88\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\u4f18\u5316\u6548\u7387\uff0c\u5e38\u89c1\u7684\u6548\u7387\u4f18\u5316\u65b9\u6cd5\u6709\u4e24\u79cd\u3002

    • \u526a\u679d\uff1a\u907f\u514d\u641c\u7d22\u90a3\u4e9b\u80af\u5b9a\u4e0d\u4f1a\u4ea7\u751f\u89e3\u7684\u8def\u5f84\uff0c\u4ece\u800c\u8282\u7701\u65f6\u95f4\u548c\u7a7a\u95f4\u3002
    • \u542f\u53d1\u5f0f\u641c\u7d22\uff1a\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/#1316","title":"13.1.6 \u00a0 \u56de\u6eaf\u5178\u578b\u4f8b\u9898","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

    \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\u6839\u67f1\u5b50\u548c\u4e00\u7cfb\u5217\u5927\u5c0f\u4e0d\u540c\u7684\u5706\u76d8\uff0c\u8981\u6c42\u5c06\u6240\u6709\u5706\u76d8\u4ece\u4e00\u6839\u67f1\u5b50\u79fb\u52a8\u5230\u53e6\u4e00\u6839\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\u5bf9\u4e8e\u8bb8\u591a\u7ec4\u5408\u4f18\u5316\u95ee\u9898\uff0c\u56de\u6eaf\u4e0d\u662f\u6700\u4f18\u89e3\u51b3\u65b9\u6848\u3002

    • 0-1 \u80cc\u5305\u95ee\u9898\u901a\u5e38\u4f7f\u7528\u52a8\u6001\u89c4\u5212\u89e3\u51b3\uff0c\u4ee5\u8fbe\u5230\u66f4\u9ad8\u7684\u65f6\u95f4\u6548\u7387\u3002
    • \u65c5\u884c\u5546\u662f\u4e00\u4e2a\u8457\u540d\u7684 NP-Hard \u95ee\u9898\uff0c\u5e38\u7528\u89e3\u6cd5\u6709\u9057\u4f20\u7b97\u6cd5\u548c\u8681\u7fa4\u7b97\u6cd5\u7b49\u3002
    • \u6700\u5927\u56e2\u95ee\u9898\u662f\u56fe\u8bba\u4e2d\u7684\u4e00\u4e2a\u7ecf\u5178\u95ee\u9898\uff0c\u53ef\u7528\u8d2a\u5fc3\u7b97\u6cd5\u7b49\u542f\u53d1\u5f0f\u7b97\u6cd5\u6765\u89e3\u51b3\u3002
    "},{"location":"chapter_backtracking/n_queens_problem/","title":"13.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\u540c\u5904\u4e00\u884c\u3001\u4e00\u5217\u6216\u4e00\u6761\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\u56fe 13-15 \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

    \u56fe 13-15 \u00a0 4 \u7687\u540e\u95ee\u9898\u7684\u89e3

    \u56fe 13-16 \u5c55\u793a\u4e86\u672c\u9898\u7684\u4e09\u4e2a\u7ea6\u675f\u6761\u4ef6\uff1a\u591a\u4e2a\u7687\u540e\u4e0d\u80fd\u5728\u540c\u4e00\u884c\u3001\u540c\u4e00\u5217\u3001\u540c\u4e00\u6761\u5bf9\u89d2\u7ebf\u4e0a\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u5bf9\u89d2\u7ebf\u5206\u4e3a\u4e3b\u5bf9\u89d2\u7ebf \\ \u548c\u6b21\u5bf9\u89d2\u7ebf / \u4e24\u79cd\u3002

    \u56fe 13-16 \u00a0 n \u7687\u540e\u95ee\u9898\u7684\u7ea6\u675f\u6761\u4ef6

    "},{"location":"chapter_backtracking/n_queens_problem/#1","title":"1. \u00a0 \u9010\u884c\u653e\u7f6e\u7b56\u7565","text":"

    \u7687\u540e\u7684\u6570\u91cf\u548c\u68cb\u76d8\u7684\u884c\u6570\u90fd\u4e3a \\(n\\) \uff0c\u56e0\u6b64\u6211\u4eec\u5bb9\u6613\u5f97\u5230\u4e00\u4e2a\u63a8\u8bba\uff1a\u68cb\u76d8\u6bcf\u884c\u90fd\u5141\u8bb8\u4e14\u53ea\u5141\u8bb8\u653e\u7f6e\u4e00\u4e2a\u7687\u540e\u3002

    \u4e5f\u5c31\u662f\u8bf4\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

    \u56fe 13-17 \u6240\u793a\u4e3a \\(4\\) \u7687\u540e\u95ee\u9898\u7684\u9010\u884c\u653e\u7f6e\u8fc7\u7a0b\u3002\u53d7\u753b\u5e45\u9650\u5236\uff0c\u56fe 13-17 \u4ec5\u5c55\u5f00\u4e86\u7b2c\u4e00\u884c\u7684\u5176\u4e2d\u4e00\u4e2a\u641c\u7d22\u5206\u652f\uff0c\u5e76\u4e14\u5c06\u4e0d\u6ee1\u8db3\u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u65b9\u6848\u90fd\u8fdb\u884c\u4e86\u526a\u679d\u3002

    \u56fe 13-17 \u00a0 \u9010\u884c\u653e\u7f6e\u7b56\u7565

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u9010\u884c\u653e\u7f6e\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

    "},{"location":"chapter_backtracking/n_queens_problem/#2","title":"2. \u00a0 \u5217\u4e0e\u5bf9\u89d2\u7ebf\u526a\u679d","text":"

    \u4e3a\u4e86\u6ee1\u8db3\u5217\u7ea6\u675f\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\u8fdb\u884c\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\u9009\u5b9a\u77e9\u9635\u4e2d\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\u90fd\u76f8\u7b49\uff0c\u5373\u5bf9\u89d2\u7ebf\u4e0a\u6240\u6709\u683c\u5b50\u7684 \\(row - col\\) \u4e3a\u6052\u5b9a\u503c\u3002

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5982\u679c\u4e24\u4e2a\u683c\u5b50\u6ee1\u8db3 \\(row_1 - col_1 = row_2 - col_2\\) \uff0c\u5219\u5b83\u4eec\u4e00\u5b9a\u5904\u5728\u540c\u4e00\u6761\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u3002\u5229\u7528\u8be5\u89c4\u5f8b\uff0c\u6211\u4eec\u53ef\u4ee5\u501f\u52a9\u56fe 13-18 \u6240\u793a\u7684\u6570\u7ec4 diags1 \u8bb0\u5f55\u6bcf\u6761\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\u3002

    \u540c\u7406\uff0c\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u7684\u6240\u6709\u683c\u5b50\u7684 \\(row + col\\) \u662f\u6052\u5b9a\u503c\u3002\u6211\u4eec\u540c\u6837\u4e5f\u53ef\u4ee5\u501f\u52a9\u6570\u7ec4 diags2 \u6765\u5904\u7406\u6b21\u5bf9\u89d2\u7ebf\u7ea6\u675f\u3002

    \u56fe 13-18 \u00a0 \u5904\u7406\u5217\u7ea6\u675f\u548c\u5bf9\u89d2\u7ebf\u7ea6\u675f

    "},{"location":"chapter_backtracking/n_queens_problem/#3","title":"3. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u8bf7\u6ce8\u610f\uff0c\\(n\\) \u7ef4\u65b9\u9635\u4e2d \\(row - col\\) \u7684\u8303\u56f4\u662f \\([-n + 1, n - 1]\\) \uff0c\\(row + col\\) \u7684\u8303\u56f4\u662f \\([0, 2n - 2]\\) \uff0c\u6240\u4ee5\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\u7684\u6570\u91cf\u90fd\u4e3a \\(2n - 1\\) \uff0c\u5373\u6570\u7ec4 diags1 \u548c diags2 \u7684\u957f\u5ea6\u90fd\u4e3a \\(2n - 1\\) \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig n_queens.py
    def backtrack(\n    row: int,\n    n: int,\n    state: list[list[str]],\n    res: list[list[list[str]]],\n    cols: list[bool],\n    diags1: list[bool],\n    diags2: list[bool],\n):\n    \"\"\"\u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e\"\"\"\n    # \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if row == n:\n        res.append([list(row) for row in state])\n        return\n    # \u904d\u5386\u6240\u6709\u5217\n    for col in range(n):\n        # \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        diag1 = row - col + n - 1\n        diag2 = row + col\n        # \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if not cols[col] and not diags1[diag1] and not 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\n            # \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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\n\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\n    state = [[\"#\" for _ in range(n)] for _ in range(n)]\n    cols = [False] * n  # \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    diags1 = [False] * (2 * n - 1)  # \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    diags2 = [False] * (2 * n - 1)  # \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    res = []\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\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,\n               vector<bool> &diags1, vector<bool> &diags2) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        res.push_back(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (int col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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;\n        }\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\n    vector<vector<string>> state(n, vector<string>(n, \"#\"));\n    vector<bool> cols(n, false);           // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    vector<bool> diags1(2 * n - 1, false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    vector<bool> diags2(2 * n - 1, false); // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    vector<vector<vector<string>>> res;\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\n
    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,\n        boolean[] cols, boolean[] diags1, boolean[] diags2) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        List<List<String>> copyState = new ArrayList<>();\n        for (List<String> sRow : state) {\n            copyState.add(new ArrayList<>(sRow));\n        }\n        res.add(copyState);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (int col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {\n            // \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\n            state.get(row).set(col, \"Q\");\n            cols[col] = diags1[diag1] = diags2[diag2] = true;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\n            state.get(row).set(col, \"#\");\n            cols[col] = diags1[diag1] = diags2[diag2] = false;\n        }\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\n    List<List<String>> state = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        List<String> row = new ArrayList<>();\n        for (int j = 0; j < n; j++) {\n            row.add(\"#\");\n        }\n        state.add(row);\n    }\n    boolean[] cols = new boolean[n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    boolean[] diags1 = new boolean[2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    boolean[] diags2 = new boolean[2 * n - 1]; // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    List<List<List<String>>> res = new ArrayList<>();\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\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,\n        bool[] cols, bool[] diags1, bool[] diags2) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        List<List<string>> copyState = [];\n        foreach (List<string> sRow in state) {\n            copyState.Add(new List<string>(sRow));\n        }\n        res.Add(copyState);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (int col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            Backtrack(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;\n        }\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\n    List<List<string>> state = [];\n    for (int i = 0; i < n; i++) {\n        List<string> row = [];\n        for (int j = 0; j < n; j++) {\n            row.Add(\"#\");\n        }\n        state.Add(row);\n    }\n    bool[] cols = new bool[n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    bool[] diags1 = new bool[2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    bool[] diags2 = new bool[2 * n - 1]; // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    List<List<List<string>>> res = [];\n\n    Backtrack(0, n, state, res, cols, diags1, diags2);\n\n    return res;\n}\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\n    if row == n {\n        newState := make([][]string, len(*state))\n        for i, _ := range newState {\n            newState[i] = make([]string, len((*state)[0]))\n            copy(newState[i], (*state)[i])\n\n        }\n        *res = append(*res, newState)\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for col := 0; col < n; col++ {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        diag1 := row - col + n - 1\n        diag2 := row + col\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if !(*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\n            backtrack(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\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\n    state := make([][]string, n)\n    for i := 0; i < n; i++ {\n        row := make([]string, n)\n        for i := 0; i < n; i++ {\n            row[i] = \"#\"\n        }\n        state[i] = row\n    }\n    // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    cols := make([]bool, n)\n    diags1 := make([]bool, 2*n-1)\n    diags2 := make([]bool, 2*n-1)\n    res := make([][][]string, 0)\n    backtrack(0, n, &state, &res, &cols, &diags1, &diags2)\n    return 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\n    if row == n {\n        res.append(state)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for col in 0 ..< n {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        let diag1 = row - col + n - 1\n        let diag2 = row + col\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if !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] = true\n            diags1[diag1] = true\n            diags2[diag2] = true\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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\n            state[row][col] = \"#\"\n            cols[col] = false\n            diags1[diag1] = false\n            diags2[diag2] = false\n        }\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\n    var state = Array(repeating: Array(repeating: \"#\", count: n), count: n)\n    var cols = Array(repeating: false, count: n) // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    var diags1 = Array(repeating: false, count: 2 * n - 1) // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    var diags2 = Array(repeating: false, count: 2 * n - 1) // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    var res: [[[String]]] = []\n\n    backtrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)\n\n    return 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\n    if (row === n) {\n        res.push(state.map((row) => row.slice()));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (let col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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;\n        }\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\n    const state = Array.from({ length: n }, () => Array(n).fill('#'));\n    const cols = Array(n).fill(false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    const diags1 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    const diags2 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    const res = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n
    n_queens.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nfunction backtrack(\n    row: number,\n    n: number,\n    state: string[][],\n    res: string[][][],\n    cols: boolean[],\n    diags1: boolean[],\n    diags2: boolean[]\n): void {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row === n) {\n        res.push(state.map((row) => row.slice()));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (let col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        const diag1 = row - col + n - 1;\n        const diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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;\n        }\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\n    const state = Array.from({ length: n }, () => Array(n).fill('#'));\n    const cols = Array(n).fill(false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    const diags1 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    const diags2 = Array(2 * n - 1).fill(false); // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    const res: string[][][] = [];\n\n    backtrack(0, n, state, res, cols, diags1, diags2);\n    return res;\n}\n
    n_queens.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nvoid backtrack(\n  int row,\n  int n,\n  List<List<String>> state,\n  List<List<List<String>>> res,\n  List<bool> cols,\n  List<bool> diags1,\n  List<bool> diags2,\n) {\n  // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (row == n) {\n    List<List<String>> copyState = [];\n    for (List<String> sRow in state) {\n      copyState.add(List.from(sRow));\n    }\n    res.add(copyState);\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u5217\n  for (int col = 0; col < n; col++) {\n    // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n    int diag1 = row - col + n - 1;\n    int diag2 = row + col;\n    // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n    if (!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] = true;\n      diags1[diag1] = true;\n      diags2[diag2] = true;\n      // \u653e\u7f6e\u4e0b\u4e00\u884c\n      backtrack(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] = false;\n      diags1[diag1] = false;\n      diags2[diag2] = false;\n    }\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\n  List<List<String>> state = List.generate(n, (index) => List.filled(n, \"#\"));\n  List<bool> cols = List.filled(n, false); // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n  List<bool> diags1 = List.filled(2 * n - 1, false); // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n  List<bool> diags2 = List.filled(2 * n - 1, false); // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n  List<List<List<String>>> res = [];\n\n  backtrack(0, n, state, res, cols, diags1, diags2);\n\n  return res;\n}\n
    n_queens.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nfn backtrack(\n    row: usize,\n    n: usize,\n    state: &mut Vec<Vec<String>>,\n    res: &mut Vec<Vec<Vec<String>>>,\n    cols: &mut [bool],\n    diags1: &mut [bool],\n    diags2: &mut [bool],\n) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if row == n {\n        let mut copy_state: Vec<Vec<String>> = Vec::new();\n        for s_row in state.clone() {\n            copy_state.push(s_row);\n        }\n        res.push(copy_state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for col in 0..n {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        let diag1 = row + n - 1 - col;\n        let diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if !cols[col] && !diags1[diag1] && !diags2[diag2] {\n            // \u5c1d\u8bd5\uff1a\u5c06\u7687\u540e\u653e\u7f6e\u5728\u8be5\u683c\u5b50\n            state.get_mut(row).unwrap()[col] = \"Q\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true);\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(row + 1, n, state, res, cols, diags1, diags2);\n            // \u56de\u9000\uff1a\u5c06\u8be5\u683c\u5b50\u6062\u590d\u4e3a\u7a7a\u4f4d\n            state.get_mut(row).unwrap()[col] = \"#\".into();\n            (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false);\n        }\n    }\n}\n\n/* \u6c42\u89e3 n \u7687\u540e */\nfn n_queens(n: usize) -> Vec<Vec<Vec<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\n    let mut state: Vec<Vec<String>> = Vec::new();\n    for _ in 0..n {\n        let mut row: Vec<String> = Vec::new();\n        for _ in 0..n {\n            row.push(\"#\".into());\n        }\n        state.push(row);\n    }\n    let mut cols = vec![false; n]; // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    let mut diags1 = vec![false; 2 * n - 1]; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    let mut diags2 = vec![false; 2 * n - 1]; // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    let mut res: Vec<Vec<Vec<String>>> = Vec::new();\n\n    backtrack(\n        0,\n        n,\n        &mut state,\n        &mut res,\n        &mut cols,\n        &mut diags1,\n        &mut diags2,\n    );\n\n    res\n}\n
    n_queens.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nvoid backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],\n               bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        res[*resSize] = (char **)malloc(sizeof(char *) * n);\n        for (int i = 0; i < n; ++i) {\n            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));\n            strcpy(res[*resSize][i], state[i]);\n        }\n        (*resSize)++;\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (int col = 0; col < n; col++) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        int diag1 = row - col + n - 1;\n        int diag2 = row + col;\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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;\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(row + 1, n, state, res, resSize, 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;\n        }\n    }\n}\n\n/* \u6c42\u89e3 n \u7687\u540e */\nchar ***nQueens(int n, int *returnSize) {\n    char state[MAX_SIZE][MAX_SIZE];\n    // \u521d\u59cb\u5316 n*n \u5927\u5c0f\u7684\u68cb\u76d8\uff0c\u5176\u4e2d 'Q' \u4ee3\u8868\u7687\u540e\uff0c'#' \u4ee3\u8868\u7a7a\u4f4d\n    for (int i = 0; i < n; ++i) {\n        for (int j = 0; j < n; ++j) {\n            state[i][j] = '#';\n        }\n        state[i][n] = '\\0';\n    }\n    bool cols[MAX_SIZE] = {false};           // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    bool diags1[2 * MAX_SIZE - 1] = {false}; // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    bool diags2[2 * MAX_SIZE - 1] = {false}; // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n\n    char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE);\n    *returnSize = 0;\n    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);\n    return res;\n}\n
    n_queens.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1an \u7687\u540e */\nfun backtrack(\n    row: Int,\n    n: Int,\n    state: List<MutableList<String>>,\n    res: MutableList<List<List<String>>?>,\n    cols: BooleanArray,\n    diags1: BooleanArray,\n    diags2: BooleanArray\n) {\n    // \u5f53\u653e\u7f6e\u5b8c\u6240\u6709\u884c\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (row == n) {\n        val copyState: MutableList<List<String>> = ArrayList()\n        for (sRow in state) {\n            copyState.add(ArrayList(sRow))\n        }\n        res.add(copyState)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u5217\n    for (col in 0..<n) {\n        // \u8ba1\u7b97\u8be5\u683c\u5b50\u5bf9\u5e94\u7684\u4e3b\u5bf9\u89d2\u7ebf\u548c\u6b21\u5bf9\u89d2\u7ebf\n        val diag1 = row - col + n - 1\n        val diag2 = row + col\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8be5\u683c\u5b50\u6240\u5728\u5217\u3001\u4e3b\u5bf9\u89d2\u7ebf\u3001\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u5b58\u5728\u7687\u540e\n        if (!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            diags2[diag2] = true\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n            // \u653e\u7f6e\u4e0b\u4e00\u884c\n            backtrack(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            diags2[diag2] = false\n            diags1[diag1] = diags2[diag2]\n            cols[col] = diags1[diag1]\n        }\n    }\n}\n\n/* \u6c42\u89e3 n \u7687\u540e */\nfun nQueens(n: Int): List<List<List<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\n    val state: MutableList<MutableList<String>> = ArrayList()\n    for (i in 0..<n) {\n        val row: MutableList<String> = ArrayList()\n        for (j in 0..<n) {\n            row.add(\"#\")\n        }\n        state.add(row)\n    }\n    val cols = BooleanArray(n) // \u8bb0\u5f55\u5217\u662f\u5426\u6709\u7687\u540e\n    val diags1 = BooleanArray(2 * n - 1) // \u8bb0\u5f55\u4e3b\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    val diags2 = BooleanArray(2 * n - 1) // \u8bb0\u5f55\u6b21\u5bf9\u89d2\u7ebf\u4e0a\u662f\u5426\u6709\u7687\u540e\n    val res: MutableList<List<List<String>>?> = ArrayList()\n\n    backtrack(0, n, state, res, cols, diags1, diags2)\n\n    return res\n}\n
    n_queens.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{n_queens}\n
    n_queens.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{nQueens}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\\)\u3001\\(n-1\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \u4e2a\u9009\u62e9\uff0c\u4f7f\u7528 \\(O(n!)\\) \u65f6\u95f4\u3002\u5f53\u8bb0\u5f55\u89e3\u65f6\uff0c\u9700\u8981\u590d\u5236\u77e9\u9635 state \u5e76\u6dfb\u52a0\u8fdb res \uff0c\u590d\u5236\u64cd\u4f5c\u4f7f\u7528 \\(O(n^2)\\) \u65f6\u95f4\u3002\u56e0\u6b64\uff0c\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n! \\cdot n^2)\\) \u3002\u5b9e\u9645\u4e0a\uff0c\u6839\u636e\u5bf9\u89d2\u7ebf\u7ea6\u675f\u7684\u526a\u679d\u4e5f\u80fd\u591f\u5927\u5e45\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

    \u6570\u7ec4 state \u4f7f\u7528 \\(O(n^2)\\) \u7a7a\u95f4\uff0c\u6570\u7ec4 cols\u3001diags1 \u548c 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":"13.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\u5176\u4e2d\u5143\u7d20\u7684\u6240\u6709\u53ef\u80fd\u7684\u6392\u5217\u3002

    \u8868 13-2 \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

    \u8868 13-2 \u00a0 \u5168\u6392\u5217\u793a\u4f8b

    \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/#1321","title":"13.2.1 \u00a0 \u65e0\u76f8\u7b49\u5143\u7d20\u7684\u60c5\u51b5","text":"

    Question

    \u8f93\u5165\u4e00\u4e2a\u6574\u6570\u6570\u7ec4\uff0c\u5176\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\\) \uff0c\u518d\u9009\u62e9 \\(3\\) \uff0c\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\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\u8bf7\u6ce8\u610f\uff0c\u6bcf\u4e2a\u5143\u7d20\u53ea\u5141\u8bb8\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u56e0\u6b64 state \u4e2d\u7684\u6240\u6709\u5143\u7d20\u90fd\u5e94\u8be5\u662f\u552f\u4e00\u7684\u3002

    \u5982\u56fe 13-5 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u641c\u7d22\u8fc7\u7a0b\u5c55\u5f00\u6210\u4e00\u68f5\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

    \u56fe 13-5 \u00a0 \u5168\u6392\u5217\u7684\u9012\u5f52\u6811

    "},{"location":"chapter_backtracking/permutations_problem/#1","title":"1. \u00a0 \u91cd\u590d\u9009\u62e9\u526a\u679d","text":"

    \u4e3a\u4e86\u5b9e\u73b0\u6bcf\u4e2a\u5143\u7d20\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\uff0c\u6211\u4eec\u8003\u8651\u5f15\u5165\u4e00\u4e2a\u5e03\u5c14\u578b\u6570\u7ec4 selected \uff0c\u5176\u4e2d selected[i] \u8868\u793a choices[i] \u662f\u5426\u5df2\u88ab\u9009\u62e9\uff0c\u5e76\u57fa\u4e8e\u5b83\u5b9e\u73b0\u4ee5\u4e0b\u526a\u679d\u64cd\u4f5c\u3002

    • \u5728\u505a\u51fa\u9009\u62e9 choice[i] \u540e\uff0c\u6211\u4eec\u5c31\u5c06 selected[i] \u8d4b\u503c\u4e3a \\(\\text{True}\\) \uff0c\u4ee3\u8868\u5b83\u5df2\u88ab\u9009\u62e9\u3002
    • \u904d\u5386\u9009\u62e9\u5217\u8868 choices \u65f6\uff0c\u8df3\u8fc7\u6240\u6709\u5df2\u88ab\u9009\u62e9\u7684\u8282\u70b9\uff0c\u5373\u526a\u679d\u3002

    \u5982\u56fe 13-6 \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 \u548c\u5143\u7d20 3 \u7684\u5206\u652f\u3002

    \u56fe 13-6 \u00a0 \u5168\u6392\u5217\u526a\u679d\u793a\u4f8b

    \u89c2\u5bdf\u56fe 13-6 \u53d1\u73b0\uff0c\u8be5\u526a\u679d\u64cd\u4f5c\u5c06\u641c\u7d22\u7a7a\u95f4\u5927\u5c0f\u4ece \\(O(n^n)\\) \u51cf\u5c0f\u81f3 \\(O(n!)\\) \u3002

    "},{"location":"chapter_backtracking/permutations_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \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\u6574\u4f53\u4ee3\u7801\uff0c\u6211\u4eec\u4e0d\u5355\u72ec\u5b9e\u73b0\u6846\u67b6\u4ee3\u7801\u4e2d\u7684\u5404\u4e2a\u51fd\u6570\uff0c\u800c\u662f\u5c06\u5b83\u4eec\u5c55\u5f00\u5728 backtrack() \u51fd\u6570\u4e2d\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig permutations_i.py
    def backtrack(\n    state: 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\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i, choice in enumerate(choices):\n        # \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if not selected[i]:\n            # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = True\n            state.append(choice)\n            # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop()\n\ndef permutations_i(nums: list[int]) -> list[list[int]]:\n    \"\"\"\u5168\u6392\u5217 I\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\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\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choices.size(); i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.push_back(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop_back();\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nvector<vector<int>> permutationsI(vector<int> nums) {\n    vector<int> state;\n    vector<bool> selected(nums.size(), false);\n    vector<vector<int>> res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n
    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\n    if (state.size() == choices.length) {\n        res.add(new ArrayList<Integer>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choices.length; i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.add(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.remove(state.size() - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nList<List<Integer>> permutationsI(int[] nums) {\n    List<List<Integer>> res = new ArrayList<List<Integer>>();\n    backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);\n    return res;\n}\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\n    if (state.Count == choices.Length) {\n        res.Add(new List<int>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choices.Length; i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.Add(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            Backtrack(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.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nList<List<int>> PermutationsI(int[] nums) {\n    List<List<int>> res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\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\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i := 0; i < len(*choices); i++ {\n        choice := (*choices)[i]\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if !(*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\n            backtrackI(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\n/* \u5168\u6392\u5217 I */\nfunc permutationsI(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackI(&state, &nums, &selected, &res)\n    return 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\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (i, choice) in choices.enumerated() {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if !selected[i] {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true\n            state.append(choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nfunc permutationsI(nums: [Int]) -> [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &state, choices: nums, selected: &selected, res: &res)\n    return 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\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    choices.forEach((choice, i) => {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop();\n        }\n    });\n}\n\n/* \u5168\u6392\u5217 I */\nfunction permutationsI(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n
    permutations_i.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    choices.forEach((choice, i) => {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop();\n        }\n    });\n}\n\n/* \u5168\u6392\u5217 I */\nfunction permutationsI(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n
    permutations_i.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(\n  List<int> state,\n  List<int> choices,\n  List<bool> selected,\n  List<List<int>> res,\n) {\n  // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (int i = 0; i < choices.length; i++) {\n    int choice = choices[i];\n    // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n    if (!selected[i]) {\n      // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n      selected[i] = true;\n      state.add(choice);\n      // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n      backtrack(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.removeLast();\n    }\n  }\n}\n\n/* \u5168\u6392\u5217 I */\nList<List<int>> permutationsI(List<int> nums) {\n  List<List<int>> res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n
    permutations_i.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfn backtrack(mut state: Vec<i32>, choices: &[i32], selected: &mut [bool], res: &mut Vec<Vec<i32>>) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i in 0..choices.len() {\n        let choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if !selected[i] {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state.clone(), 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.remove(state.len() - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nfn permutations_i(nums: &mut [i32]) -> Vec<Vec<i32>> {\n    let mut res = Vec::new(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);\n    res\n}\n
    permutations_i.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i < choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choicesSize; i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true;\n            state[stateSize] = choice;\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            selected[i] = false;\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nint **permutationsI(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i < numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n
    permutations_i.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 I */\nfun backtrack(\n    state: MutableList<Int>,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList<List<Int>?>\n) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (state.size == choices.size) {\n        res.add(ArrayList(state))\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (i in choices.indices) {\n        val choice = choices[i]\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u91cd\u590d\u9009\u62e9\u5143\u7d20\n        if (!selected[i]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            selected[i] = true\n            state.add(choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 I */\nfun permutationsI(nums: IntArray): List<List<Int>?> {\n    val res: MutableList<List<Int>?> = ArrayList()\n    backtrack(ArrayList(), nums, BooleanArray(nums.size), res)\n    return res\n}\n
    permutations_i.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{permutations_i}\n
    permutations_i.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{permutationsI}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_backtracking/permutations_problem/#1322","title":"13.2.2 \u00a0 \u8003\u8651\u76f8\u7b49\u5143\u7d20\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\u5143\u7d20 \\(1\\) \uff0c\u6211\u4eec\u5c06\u7b2c\u4e8c\u4e2a \\(1\\) \u8bb0\u4e3a \\(\\hat{1}\\) \u3002

    \u5982\u56fe 13-7 \u6240\u793a\uff0c\u4e0a\u8ff0\u65b9\u6cd5\u751f\u6210\u7684\u6392\u5217\u6709\u4e00\u534a\u662f\u91cd\u590d\u7684\u3002

    \u56fe 13-7 \u00a0 \u91cd\u590d\u6392\u5217

    \u90a3\u4e48\u5982\u4f55\u53bb\u9664\u91cd\u590d\u7684\u6392\u5217\u5462\uff1f\u6700\u76f4\u63a5\u5730\uff0c\u8003\u8651\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\u6ca1\u6709\u5fc5\u8981\uff0c\u5e94\u5f53\u63d0\u524d\u8bc6\u522b\u5e76\u526a\u679d\uff0c\u8fd9\u6837\u53ef\u4ee5\u8fdb\u4e00\u6b65\u63d0\u5347\u7b97\u6cd5\u6548\u7387\u3002

    "},{"location":"chapter_backtracking/permutations_problem/#1_1","title":"1. \u00a0 \u76f8\u7b49\u5143\u7d20\u526a\u679d","text":"

    \u89c2\u5bdf\u56fe 13-8 \uff0c\u5728\u7b2c\u4e00\u8f6e\u4e2d\uff0c\u9009\u62e9 \\(1\\) \u6216\u9009\u62e9 \\(\\hat{1}\\) \u662f\u7b49\u4ef7\u7684\uff0c\u5728\u8fd9\u4e24\u4e2a\u9009\u62e9\u4e4b\u4e0b\u751f\u6210\u7684\u6240\u6709\u6392\u5217\u90fd\u662f\u91cd\u590d\u7684\u3002\u56e0\u6b64\u5e94\u8be5\u628a \\(\\hat{1}\\) \u526a\u679d\u3002

    \u540c\u7406\uff0c\u5728\u7b2c\u4e00\u8f6e\u9009\u62e9 \\(2\\) \u4e4b\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\u5e94\u5c06\u7b2c\u4e8c\u8f6e\u7684 \\(\\hat{1}\\) \u526a\u679d\u3002

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u6211\u4eec\u7684\u76ee\u6807\u662f\u5728\u67d0\u4e00\u8f6e\u9009\u62e9\u4e2d\uff0c\u4fdd\u8bc1\u591a\u4e2a\u76f8\u7b49\u7684\u5143\u7d20\u4ec5\u88ab\u9009\u62e9\u4e00\u6b21\u3002

    \u56fe 13-8 \u00a0 \u91cd\u590d\u6392\u5217\u526a\u679d

    "},{"location":"chapter_backtracking/permutations_problem/#2_1","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig permutations_ii.py
    def backtrack(\n    state: 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\n    if len(state) == len(choices):\n        res.append(list(state))\n        return\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    duplicated = set[int]()\n    for 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\n        if not selected[i] and choice not in duplicated:\n            # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice)  # \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = True\n            state.append(choice)\n            # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop()\n\ndef permutations_ii(nums: list[int]) -> list[list[int]]:\n    \"\"\"\u5168\u6392\u5217 II\"\"\"\n    res = []\n    backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)\n    return res\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\n    if (state.size() == choices.size()) {\n        res.push_back(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    unordered_set<int> duplicated;\n    for (int i = 0; i < choices.size(); i++) {\n        int 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\n        if (!selected[i] && duplicated.find(choice) == duplicated.end()) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.emplace(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.push_back(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop_back();\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nvector<vector<int>> permutationsII(vector<int> nums) {\n    vector<int> state;\n    vector<bool> selected(nums.size(), false);\n    vector<vector<int>> res;\n    backtrack(state, nums, selected, res);\n    return res;\n}\n
    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\n    if (state.size() == choices.length) {\n        res.add(new ArrayList<Integer>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    Set<Integer> duplicated = new HashSet<Integer>();\n    for (int i = 0; i < choices.length; i++) {\n        int 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\n        if (!selected[i] && !duplicated.contains(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.add(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.remove(state.size() - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nList<List<Integer>> permutationsII(int[] nums) {\n    List<List<Integer>> res = new ArrayList<List<Integer>>();\n    backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);\n    return res;\n}\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\n    if (state.Count == choices.Length) {\n        res.Add(new List<int>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    HashSet<int> duplicated = [];\n    for (int i = 0; i < choices.Length; i++) {\n        int 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\n        if (!selected[i] && !duplicated.Contains(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.Add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.Add(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            Backtrack(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.RemoveAt(state.Count - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nList<List<int>> PermutationsII(int[] nums) {\n    List<List<int>> res = [];\n    Backtrack([], nums, new bool[nums.Length], res);\n    return res;\n}\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\n    if len(*state) == len(*choices) {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    duplicated := make(map[int]struct{}, 0)\n    for i := 0; i < len(*choices); i++ {\n        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\n        if _, 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\n            duplicated[choice] = struct{}{}\n            (*selected)[i] = true\n            *state = append(*state, choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrackI(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\n/* \u5168\u6392\u5217 II */\nfunc permutationsII(nums []int) [][]int {\n    res := make([][]int, 0)\n    state := make([]int, 0)\n    selected := make([]bool, len(nums))\n    backtrackII(&state, &nums, &selected, &res)\n    return 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\n    if state.count == choices.count {\n        res.append(state)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    var duplicated: Set<Int> = []\n    for (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\n        if !selected[i], !duplicated.contains(choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.insert(choice) // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true\n            state.append(choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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\n            selected[i] = false\n            state.removeLast()\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nfunc permutationsII(nums: [Int]) -> [[Int]] {\n    var state: [Int] = []\n    var selected = Array(repeating: false, count: nums.count)\n    var res: [[Int]] = []\n    backtrack(state: &state, choices: nums, selected: &selected, res: &res)\n    return 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\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    const duplicated = new Set();\n    choices.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\n        if (!selected[i] && !duplicated.has(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop();\n        }\n    });\n}\n\n/* \u5168\u6392\u5217 II */\nfunction permutationsII(nums) {\n    const res = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n
    permutations_ii.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfunction backtrack(\n    state: number[],\n    choices: number[],\n    selected: boolean[],\n    res: number[][]\n): void {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (state.length === choices.length) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    const duplicated = new Set();\n    choices.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\n        if (!selected[i] && !duplicated.has(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.pop();\n        }\n    });\n}\n\n/* \u5168\u6392\u5217 II */\nfunction permutationsII(nums: number[]): number[][] {\n    const res: number[][] = [];\n    backtrack([], nums, Array(nums.length).fill(false), res);\n    return res;\n}\n
    permutations_ii.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(\n  List<int> state,\n  List<int> choices,\n  List<bool> selected,\n  List<List<int>> res,\n) {\n  // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (state.length == choices.length) {\n    res.add(List.from(state));\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  Set<int> duplicated = {};\n  for (int i = 0; i < choices.length; i++) {\n    int 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\n    if (!selected[i] && !duplicated.contains(choice)) {\n      // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n      duplicated.add(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n      selected[i] = true;\n      state.add(choice);\n      // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n      backtrack(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.removeLast();\n    }\n  }\n}\n\n/* \u5168\u6392\u5217 II */\nList<List<int>> permutationsII(List<int> nums) {\n  List<List<int>> res = [];\n  backtrack([], nums, List.filled(nums.length, false), res);\n  return res;\n}\n
    permutations_ii.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfn backtrack(mut state: Vec<i32>, choices: &[i32], selected: &mut [bool], res: &mut Vec<Vec<i32>>) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if state.len() == choices.len() {\n        res.push(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    let mut duplicated = HashSet::<i32>::new();\n    for i in 0..choices.len() {\n        let 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\n        if !selected[i] && !duplicated.contains(&choice) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.insert(choice); // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state.push(choice);\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state.clone(), 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.remove(state.len() - 1);\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nfn permutations_ii(nums: &mut [i32]) -> Vec<Vec<i32>> {\n    let mut res = Vec::new();\n    backtrack(Vec::new(), nums, &mut vec![false; nums.len()], &mut res);\n    res\n}\n
    permutations_ii.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nvoid backtrack(int *state, int stateSize, int *choices, int choicesSize, bool *selected, int **res, int *resSize) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (stateSize == choicesSize) {\n        res[*resSize] = (int *)malloc(choicesSize * sizeof(int));\n        for (int i = 0; i < choicesSize; i++) {\n            res[*resSize][i] = state[i];\n        }\n        (*resSize)++;\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    bool duplicated[MAX_SIZE] = {false};\n    for (int i = 0; i < choicesSize; i++) {\n        int 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\n        if (!selected[i] && !duplicated[choice]) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated[choice] = true; // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true;\n            state[stateSize] = choice;\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(state, stateSize + 1, choices, choicesSize, selected, res, resSize);\n            // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n            selected[i] = false;\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nint **permutationsII(int *nums, int numsSize, int *returnSize) {\n    int *state = (int *)malloc(numsSize * sizeof(int));\n    bool *selected = (bool *)malloc(numsSize * sizeof(bool));\n    for (int i = 0; i < numsSize; i++) {\n        selected[i] = false;\n    }\n    int **res = (int **)malloc(MAX_SIZE * sizeof(int *));\n    *returnSize = 0;\n\n    backtrack(state, 0, nums, numsSize, selected, res, returnSize);\n\n    free(state);\n    free(selected);\n\n    return res;\n}\n
    permutations_ii.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5168\u6392\u5217 II */\nfun backtrack(\n    state: MutableList<Int>,\n    choices: IntArray,\n    selected: BooleanArray,\n    res: MutableList<MutableList<Int>?>\n) {\n    // \u5f53\u72b6\u6001\u957f\u5ea6\u7b49\u4e8e\u5143\u7d20\u6570\u91cf\u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (state.size == choices.size) {\n        res.add(ArrayList(state))\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    val duplicated: MutableSet<Int> = HashSet()\n    for (i in choices.indices) {\n        val 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\n        if (!selected[i] && !duplicated.contains(choice)) {\n            // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n            duplicated.add(choice) // \u8bb0\u5f55\u9009\u62e9\u8fc7\u7684\u5143\u7d20\u503c\n            selected[i] = true\n            state.add(choice)\n            // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n            backtrack(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.removeAt(state.size - 1)\n        }\n    }\n}\n\n/* \u5168\u6392\u5217 II */\nfun permutationsII(nums: IntArray): MutableList<MutableList<Int>?> {\n    val res: MutableList<MutableList<Int>?> = ArrayList()\n    backtrack(ArrayList(), nums, BooleanArray(nums.size), res)\n    return res\n}\n
    permutations_ii.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{permutations_ii}\n
    permutations_ii.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{permutationsII}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\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\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_backtracking/permutations_problem/#3","title":"3. \u00a0 \u4e24\u79cd\u526a\u679d\u5bf9\u6bd4","text":"

    \u8bf7\u6ce8\u610f\uff0c\u867d\u7136 selected \u548c duplicated \u90fd\u7528\u4e8e\u526a\u679d\uff0c\u4f46\u4e24\u8005\u7684\u76ee\u6807\u4e0d\u540c\u3002

    • \u91cd\u590d\u9009\u62e9\u526a\u679d\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\u5176\u4f5c\u7528\u662f\u907f\u514d\u67d0\u4e2a\u5143\u7d20\u5728 state \u4e2d\u91cd\u590d\u51fa\u73b0\u3002
    • \u76f8\u7b49\u5143\u7d20\u526a\u679d\uff1a\u6bcf\u8f6e\u9009\u62e9\uff08\u6bcf\u4e2a\u8c03\u7528\u7684 backtrack \u51fd\u6570\uff09\u90fd\u5305\u542b\u4e00\u4e2a duplicated \u3002\u5b83\u8bb0\u5f55\u7684\u662f\u5728\u672c\u8f6e\u904d\u5386\uff08for \u5faa\u73af\uff09\u4e2d\u54ea\u4e9b\u5143\u7d20\u5df2\u88ab\u9009\u62e9\u8fc7\uff0c\u5176\u4f5c\u7528\u662f\u4fdd\u8bc1\u76f8\u7b49\u5143\u7d20\u53ea\u88ab\u9009\u62e9\u4e00\u6b21\u3002

    \u56fe 13-9 \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

    \u56fe 13-9 \u00a0 \u4e24\u79cd\u526a\u679d\u6761\u4ef6\u7684\u4f5c\u7528\u8303\u56f4

    "},{"location":"chapter_backtracking/subset_sum_problem/","title":"13.3 \u00a0 \u5b50\u96c6\u548c\u95ee\u9898","text":""},{"location":"chapter_backtracking/subset_sum_problem/#1331","title":"13.3.1 \u00a0 \u65e0\u91cd\u590d\u5143\u7d20\u7684\u60c5\u51b5","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\u89e3\u4e3a \\(\\{3, 3, 3\\}, \\{4, 5\\}\\) \u3002\u9700\u8981\u6ce8\u610f\u4ee5\u4e0b\u4e24\u70b9\u3002

    • \u8f93\u5165\u96c6\u5408\u4e2d\u7684\u5143\u7d20\u53ef\u4ee5\u88ab\u65e0\u9650\u6b21\u91cd\u590d\u9009\u53d6\u3002
    • \u5b50\u96c6\u4e0d\u533a\u5206\u5143\u7d20\u987a\u5e8f\uff0c\u6bd4\u5982 \\(\\{4, 5\\}\\) \u548c \\(\\{5, 4\\}\\) \u662f\u540c\u4e00\u4e2a\u5b50\u96c6\u3002
    "},{"location":"chapter_backtracking/subset_sum_problem/#1","title":"1. \u00a0 \u53c2\u8003\u5168\u6392\u5217\u89e3\u6cd5","text":"

    \u7c7b\u4f3c\u4e8e\u5168\u6392\u5217\u95ee\u9898\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\u96c6\u5408\u4e2d\u7684\u5143\u7d20\u53ef\u4ee5\u88ab\u65e0\u9650\u6b21\u9009\u53d6\uff0c\u56e0\u6b64\u65e0\u987b\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig subset_sum_i_naive.py
    def backtrack(\n    state: list[int],\n    target: int,\n    total: int,\n    choices: list[int],\n    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\n    if total == target:\n        res.append(list(state))\n        return\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i in range(len(choices)):\n        # \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if total + choices[i] > target:\n            continue\n        # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.append(choices[i])\n        # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res)\n        # \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop()\n\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\"\"\"\n    state = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    total = 0  # \u5b50\u96c6\u548c\n    res = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res)\n    return res\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\n    if (total == target) {\n        res.push_back(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (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\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.push_back(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop_back();\n    }\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) {\n    vector<int> state;       // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    int total = 0;           // \u5b50\u96c6\u548c\n    vector<vector<int>> res; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n
    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\n    if (total == target) {\n        res.add(new ArrayList<>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (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\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.remove(state.size() - 1);\n    }\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) {\n    List<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    int total = 0; // \u5b50\u96c6\u548c\n    List<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res);\n    return res;\n}\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\n    if (total == target) {\n        res.Add(new List<int>(state));\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (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\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.Add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        Backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.RemoveAt(state.Count - 1);\n    }\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) {\n    List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    int total = 0; // \u5b50\u96c6\u548c\n    List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    Backtrack(state, target, total, nums, res);\n    return res;\n}\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\n    if target == total {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i := 0; i < len(*choices); i++ {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if total+(*choices)[i] > target {\n            continue\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\n        backtrackSubsetSumINaive(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\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunc subsetSumINaive(nums []int, target int) [][]int {\n    state := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    total := 0              // \u5b50\u96c6\u548c\n    res := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrackSubsetSumINaive(total, target, &state, &nums, &res)\n    return 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\n    if total == target {\n        res.append(state)\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i in choices.indices {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if total + choices[i] > target {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.append(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.removeLast()\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunc subsetSumINaive(nums: [Int], target: Int) -> [[Int]] {\n    var state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    let total = 0 // \u5b50\u96c6\u548c\n    var res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state: &state, target: target, total: total, choices: nums, res: &res)\n    return res\n}\n
    subset_sum_i_naive.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunction backtrack(state, target, total, choices, res) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (let i = 0; i < choices.length; i++) {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunction subsetSumINaive(nums, target) {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    const total = 0; // \u5b50\u96c6\u548c\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n
    subset_sum_i_naive.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    total: number,\n    choices: number[],\n    res: number[][]\n): void {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (total === target) {\n        res.push([...state]);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (let i = 0; i < choices.length; i++) {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfunction subsetSumINaive(nums: number[], target: number): number[][] {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    const total = 0; // \u5b50\u96c6\u548c\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res);\n    return res;\n}\n
    subset_sum_i_naive.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(\n  List<int> state,\n  int target,\n  int total,\n  List<int> choices,\n  List<List<int>> res,\n) {\n  // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (total == target) {\n    res.add(List.from(state));\n    return;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (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\n    if (total + choices[i] > target) {\n      continue;\n    }\n    // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n    state.add(choices[i]);\n    // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n    backtrack(state, target, total + choices[i], choices, res);\n    // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n    state.removeLast();\n  }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nList<List<int>> subsetSumINaive(List<int> nums, int target) {\n  List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n  int total = 0; // \u5143\u7d20\u548c\n  List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n  backtrack(state, target, total, nums, res);\n  return res;\n}\n
    subset_sum_i_naive.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfn backtrack(\n    mut state: Vec<i32>,\n    target: i32,\n    total: i32,\n    choices: &[i32],\n    res: &mut Vec<Vec<i32>>,\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if total == target {\n        res.push(state);\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for i in 0..choices.len() {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if total + choices[i] > target {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state.clone(), target, total + choices[i], choices, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfn subset_sum_i_naive(nums: &[i32], target: i32) -> Vec<Vec<i32>> {\n    let state = Vec::new(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    let total = 0; // \u5b50\u96c6\u548c\n    let mut res = Vec::new(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, &mut res);\n    res\n}\n
    subset_sum_i_naive.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(int target, int total, int *choices, int choicesSize) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (total == target) {\n        for (int i = 0; i < stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < choicesSize; i++) {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if (total + choices[i] > target) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state[stateSize++] = choices[i];\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(target, total + choices[i], choices, choicesSize);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        stateSize--;\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nvoid subsetSumINaive(int *nums, int numsSize, int target) {\n    resSize = 0; // \u521d\u59cb\u5316\u89e3\u7684\u6570\u91cf\u4e3a0\n    backtrack(target, 0, nums, numsSize);\n}\n
    subset_sum_i_naive.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfun backtrack(\n    state: MutableList<Int>,\n    target: Int,\n    total: Int,\n    choices: IntArray,\n    res: MutableList<List<Int>?>\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (total == target) {\n        res.add(ArrayList(state))\n        return\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (i in choices.indices) {\n        // \u526a\u679d\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u8df3\u8fc7\u8be5\u9009\u62e9\n        if (total + choices[i] > target) {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u5143\u7d20\u548c total\n        state.add(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target, total + choices[i], choices, res)\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I\uff08\u5305\u542b\u91cd\u590d\u5b50\u96c6\uff09 */\nfun subsetSumINaive(nums: IntArray, target: Int): List<List<Int>?> {\n    val state: MutableList<Int> = ArrayList() // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    val total = 0 // \u5b50\u96c6\u548c\n    val res: MutableList<List<Int>?> = ArrayList() // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, total, nums, res)\n    return res\n}\n
    subset_sum_i_naive.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subset_sum_i_naive}\n
    subset_sum_i_naive.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subsetSumINaive}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\u7136\u800c\u5b50\u96c6\u4e0d\u533a\u5206\u9009\u62e9\u987a\u5e8f\u3002\u5982\u56fe 13-10 \u6240\u793a\uff0c\u5148\u9009 \\(4\\) \u540e\u9009 \\(5\\) \u4e0e\u5148\u9009 \\(5\\) \u540e\u9009 \\(4\\) \u662f\u4e0d\u540c\u7684\u5206\u652f\uff0c\u4f46\u5bf9\u5e94\u540c\u4e00\u4e2a\u5b50\u96c6\u3002

    \u56fe 13-10 \u00a0 \u5b50\u96c6\u641c\u7d22\u4e0e\u8d8a\u754c\u526a\u679d

    \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\u6709\u4e24\u65b9\u9762\u539f\u56e0\u3002

    • \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\u975e\u5e38\u8017\u65f6\uff0c\u9700\u8981\u5148\u6392\u5e8f\u6570\u7ec4\uff0c\u518d\u6bd4\u8f83\u6570\u7ec4\u4e2d\u6bcf\u4e2a\u5143\u7d20\u7684\u5f02\u540c\u3002
    "},{"location":"chapter_backtracking/subset_sum_problem/#2","title":"2. \u00a0 \u91cd\u590d\u5b50\u96c6\u526a\u679d","text":"

    \u6211\u4eec\u8003\u8651\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u901a\u8fc7\u526a\u679d\u8fdb\u884c\u53bb\u91cd\u3002\u89c2\u5bdf\u56fe 13-11 \uff0c\u91cd\u590d\u5b50\u96c6\u662f\u5728\u4ee5\u4e0d\u540c\u987a\u5e8f\u9009\u62e9\u6570\u7ec4\u5143\u7d20\u65f6\u4ea7\u751f\u7684\uff0c\u4f8b\u5982\u4ee5\u4e0b\u60c5\u51b5\u3002

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

    \u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\uff0c\u6bcf\u4e00\u5c42\u7684\u9009\u62e9\u90fd\u662f\u4ece\u5de6\u5230\u53f3\u88ab\u9010\u4e2a\u5c1d\u8bd5\u7684\uff0c\u56e0\u6b64\u8d8a\u9760\u53f3\u7684\u5206\u652f\u88ab\u526a\u6389\u7684\u8d8a\u591a\u3002

    1. \u524d\u4e24\u8f6e\u9009\u62e9 \\(3\\) \u548c \\(5\\) \uff0c\u751f\u6210\u5b50\u96c6 \\([3, 5, \\dots]\\) \u3002
    2. \u524d\u4e24\u8f6e\u9009\u62e9 \\(4\\) \u548c \\(5\\) \uff0c\u751f\u6210\u5b50\u96c6 \\([4, 5, \\dots]\\) \u3002
    3. \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, \\dots]\\) \u548c \\([5, 4, \\dots]\\) \u4e0e\u7b2c 1. \u6b65\u548c\u7b2c 2. \u6b65\u4e2d\u63cf\u8ff0\u7684\u5b50\u96c6\u5b8c\u5168\u91cd\u590d\u3002

    \u56fe 13-11 \u00a0 \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, \\dots, x_n]\\) \uff0c\u8bbe\u641c\u7d22\u8fc7\u7a0b\u4e2d\u7684\u9009\u62e9\u5e8f\u5217\u4e3a \\([x_{i_1}, x_{i_2}, \\dots, x_{i_m}]\\) \uff0c\u5219\u8be5\u9009\u62e9\u5e8f\u5217\u9700\u8981\u6ee1\u8db3 \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) \uff0c\u4e0d\u6ee1\u8db3\u8be5\u6761\u4ef6\u7684\u9009\u62e9\u5e8f\u5217\u90fd\u4f1a\u9020\u6210\u91cd\u590d\uff0c\u5e94\u5f53\u526a\u679d\u3002

    "},{"location":"chapter_backtracking/subset_sum_problem/#3","title":"3. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u4e3a\u5b9e\u73b0\u8be5\u526a\u679d\uff0c\u6211\u4eec\u521d\u59cb\u5316\u53d8\u91cf start \uff0c\u7528\u4e8e\u6307\u793a\u904d\u5386\u8d77\u59cb\u70b9\u3002\u5f53\u505a\u51fa\u9009\u62e9 \\(x_{i}\\) \u540e\uff0c\u8bbe\u5b9a\u4e0b\u4e00\u8f6e\u4ece\u7d22\u5f15 \\(i\\) \u5f00\u59cb\u904d\u5386\u3002\u8fd9\u6837\u505a\u5c31\u53ef\u4ee5\u8ba9\u9009\u62e9\u5e8f\u5217\u6ee1\u8db3 \\(i_1 \\leq i_2 \\leq \\dots \\leq i_m\\) \uff0c\u4ece\u800c\u4fdd\u8bc1\u5b50\u96c6\u552f\u4e00\u3002

    \u9664\u6b64\u4e4b\u5916\uff0c\u6211\u4eec\u8fd8\u5bf9\u4ee3\u7801\u8fdb\u884c\u4e86\u4ee5\u4e0b\u4e24\u9879\u4f18\u5316\u3002

    • \u5728\u5f00\u542f\u641c\u7d22\u524d\uff0c\u5148\u5c06\u6570\u7ec4 nums \u6392\u5e8f\u3002\u5728\u904d\u5386\u6240\u6709\u9009\u62e9\u65f6\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\u4e00\u5b9a\u8d85\u8fc7 target \u3002
    • \u7701\u53bb\u5143\u7d20\u548c\u53d8\u91cf total \uff0c\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\u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig subset_sum_i.py
    def backtrack(\n    state: 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\n    if target == 0:\n        res.append(list(state))\n        return\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    for 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\n        if target - choices[i] < 0:\n            break\n        # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.append(choices[i])\n        # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res)\n        # \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop()\n\ndef subset_sum_i(nums: list[int], target: int) -> list[list[int]]:\n    \"\"\"\u6c42\u89e3\u5b50\u96c6\u548c I\"\"\"\n    state = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort()  # \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    start = 0  # \u904d\u5386\u8d77\u59cb\u70b9\n    res = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res)\n    return res\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\n    if (target == 0) {\n        res.push_back(state);\n        return;\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    for (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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push_back(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop_back();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nvector<vector<int>> subsetSumI(vector<int> &nums, int target) {\n    vector<int> state;              // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    sort(nums.begin(), nums.end()); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0;                  // \u904d\u5386\u8d77\u59cb\u70b9\n    vector<vector<int>> res;        // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    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\n    if (target == 0) {\n        res.add(new ArrayList<>(state));\n        return;\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    for (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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.remove(state.size() - 1);\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<Integer>> subsetSumI(int[] nums, int target) {\n    List<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Arrays.sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    List<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\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\n    if (target == 0) {\n        res.Add(new List<int>(state));\n        return;\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    for (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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.Add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        Backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<int>> SubsetSumI(int[] nums, int target) {\n    List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Array.Sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\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\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\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    for 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\n        if target-(*choices)[i] < 0 {\n            break\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\n        backtrackSubsetSumI(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\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunc subsetSumI(nums []int, target int) [][]int {\n    state := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    sort.Ints(nums)         // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    start := 0              // \u904d\u5386\u8d77\u59cb\u70b9\n    res := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrackSubsetSumI(start, target, &state, &nums, &res)\n    return 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\n    if target == 0 {\n        res.append(state)\n        return\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    for i in choices.indices.dropFirst(start) {\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\n        if target - choices[i] < 0 {\n            break\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.append(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.removeLast()\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunc subsetSumI(nums: [Int], target: Int) -> [[Int]] {\n    var state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    let nums = nums.sorted() // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    let start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\n    var res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state: &state, target: target, choices: nums, start: start, res: &res)\n    return res\n}\n
    subset_sum_i.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunction backtrack(state, target, choices, start, res) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target === 0) {\n        res.push([...state]);\n        return;\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    for (let 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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunction subsetSumI(nums, target) {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort((a, b) => a - b); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    const start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    subset_sum_i.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target === 0) {\n        res.push([...state]);\n        return;\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    for (let 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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfunction subsetSumI(nums: number[], target: number): number[][] {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort((a, b) => a - b); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    const start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    subset_sum_i.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(\n  List<int> state,\n  int target,\n  List<int> choices,\n  int start,\n  List<List<int>> res,\n) {\n  // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\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  for (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\n    if (target - choices[i] < 0) {\n      break;\n    }\n    // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n    state.add(choices[i]);\n    // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n    backtrack(state, target - choices[i], choices, i, res);\n    // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n    state.removeLast();\n  }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nList<List<int>> subsetSumI(List<int> nums, int target) {\n  List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n  nums.sort(); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n  int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n  List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n
    subset_sum_i.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfn backtrack(\n    mut state: Vec<i32>,\n    target: i32,\n    choices: &[i32],\n    start: usize,\n    res: &mut Vec<Vec<i32>>,\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if target == 0 {\n        res.push(state);\n        return;\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    for i in start..choices.len() {\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\n        if target - choices[i] < 0 {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state.clone(), target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfn subset_sum_i(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {\n    let state = Vec::new(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort(); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    let start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    let mut res = Vec::new(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, &mut res);\n    res\n}\n
    subset_sum_i.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target == 0) {\n        for (int i = 0; i < stateSize; ++i) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\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    for (int i = start; i < choicesSize; 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\n        if (target - choices[i] < 0) {\n            break;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(target - choices[i], choices, choicesSize, i);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        stateSize--;\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nvoid subsetSumI(int *nums, int numsSize, int target) {\n    qsort(nums, numsSize, sizeof(int), cmp); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0;                           // \u904d\u5386\u8d77\u59cb\u70b9\n    backtrack(target, nums, numsSize, start);\n}\n
    subset_sum_i.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c I */\nfun backtrack(\n    state: MutableList<Int>,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList<List<Int>?>\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target == 0) {\n        res.add(ArrayList(state))\n        return\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    for (i in start..<choices.size) {\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\n        if (target - choices[i] < 0) {\n            break\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.add(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state, target - choices[i], choices, i, res)\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c I */\nfun subsetSumI(nums: IntArray, target: Int): List<List<Int>?> {\n    val state: MutableList<Int> = ArrayList() // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Arrays.sort(nums) // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    val start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\n    val res: MutableList<List<Int>?> = ArrayList() // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res)\n    return res\n}\n
    subset_sum_i.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subset_sum_i}\n
    subset_sum_i.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subsetSumI}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

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

    \u56fe 13-12 \u00a0 \u5b50\u96c6\u548c I \u56de\u6eaf\u8fc7\u7a0b

    "},{"location":"chapter_backtracking/subset_sum_problem/#1332","title":"13.3.2 \u00a0 \u8003\u8651\u91cd\u590d\u5143\u7d20\u7684\u60c5\u51b5","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\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\u5728\u56fe 13-13 \u4e2d\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

    \u56fe 13-13 \u00a0 \u76f8\u7b49\u5143\u7d20\u5bfc\u81f4\u7684\u91cd\u590d\u5b50\u96c6

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

    \u4e3a\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u9700\u8981\u9650\u5236\u76f8\u7b49\u5143\u7d20\u5728\u6bcf\u4e00\u8f6e\u4e2d\u53ea\u80fd\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\u8fd9\u610f\u5473\u7740\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\u6bcf\u4e2a\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\u65e2\u80fd\u53bb\u9664\u91cd\u590d\u5b50\u96c6\uff0c\u4e5f\u80fd\u907f\u514d\u91cd\u590d\u9009\u62e9\u5143\u7d20\u3002

    "},{"location":"chapter_backtracking/subset_sum_problem/#2_1","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig subset_sum_ii.py
    def backtrack(\n    state: 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\n    if target == 0:\n        res.append(list(state))\n        return\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\n    for 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\n        if target - choices[i] < 0:\n            break\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\n        if i > start and choices[i] == choices[i - 1]:\n            continue\n        # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.append(choices[i])\n        # \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.pop()\n\ndef subset_sum_ii(nums: list[int], target: int) -> list[list[int]]:\n    \"\"\"\u6c42\u89e3\u5b50\u96c6\u548c II\"\"\"\n    state = []  # \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort()  # \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    start = 0  # \u904d\u5386\u8d77\u59cb\u70b9\n    res = []  # \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res)\n    return res\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\n    if (target == 0) {\n        res.push_back(state);\n        return;\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\n    for (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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push_back(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.pop_back();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nvector<vector<int>> subsetSumII(vector<int> &nums, int target) {\n    vector<int> state;              // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    sort(nums.begin(), nums.end()); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0;                  // \u904d\u5386\u8d77\u59cb\u70b9\n    vector<vector<int>> res;        // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    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\n    if (target == 0) {\n        res.add(new ArrayList<>(state));\n        return;\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\n    for (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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.remove(state.size() - 1);\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<Integer>> subsetSumII(int[] nums, int target) {\n    List<Integer> state = new ArrayList<>(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Arrays.sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    List<List<Integer>> res = new ArrayList<>(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\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\n    if (target == 0) {\n        res.Add(new List<int>(state));\n        return;\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\n    for (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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.Add(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        Backtrack(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\n        state.RemoveAt(state.Count - 1);\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<int>> SubsetSumII(int[] nums, int target) {\n    List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Array.Sort(nums); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    Backtrack(state, target, nums, start, res);\n    return res;\n}\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\n    if target == 0 {\n        newState := append([]int{}, *state...)\n        *res = append(*res, newState)\n        return\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\n    for 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\n        if target-(*choices)[i] < 0 {\n            break\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\n        if i > start && (*choices)[i] == (*choices)[i-1] {\n            continue\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\n        backtrackSubsetSumII(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\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunc subsetSumII(nums []int, target int) [][]int {\n    state := make([]int, 0) // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    sort.Ints(nums)         // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    start := 0              // \u904d\u5386\u8d77\u59cb\u70b9\n    res := make([][]int, 0) // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrackSubsetSumII(start, target, &state, &nums, &res)\n    return 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\n    if target == 0 {\n        res.append(state)\n        return\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\n    for i in choices.indices.dropFirst(start) {\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\n        if target - choices[i] < 0 {\n            break\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\n        if i > start, choices[i] == choices[i - 1] {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.append(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.removeLast()\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunc subsetSumII(nums: [Int], target: Int) -> [[Int]] {\n    var state: [Int] = [] // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    let nums = nums.sorted() // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    let start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\n    var res: [[Int]] = [] // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state: &state, target: target, choices: nums, start: start, res: &res)\n    return res\n}\n
    subset_sum_ii.js
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfunction backtrack(state, target, choices, start, res) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target === 0) {\n        res.push([...state]);\n        return;\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\n    for (let 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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunction subsetSumII(nums, target) {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort((a, b) => a - b); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    const start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    subset_sum_ii.ts
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfunction backtrack(\n    state: number[],\n    target: number,\n    choices: number[],\n    start: number,\n    res: number[][]\n): void {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target === 0) {\n        res.push([...state]);\n        return;\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\n    for (let 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\n        if (target - choices[i] < 0) {\n            break;\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\n        if (i > start && choices[i] === choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfunction subsetSumII(nums: number[], target: number): number[][] {\n    const state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort((a, b) => a - b); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    const start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    const res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res);\n    return res;\n}\n
    subset_sum_ii.dart
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(\n  List<int> state,\n  int target,\n  List<int> choices,\n  int start,\n  List<List<int>> res,\n) {\n  // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n  if (target == 0) {\n    res.add(List.from(state));\n    return;\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\n  for (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\n    if (target - choices[i] < 0) {\n      break;\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\n    if (i > start && choices[i] == choices[i - 1]) {\n      continue;\n    }\n    // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n    state.add(choices[i]);\n    // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n    backtrack(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\n    state.removeLast();\n  }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nList<List<int>> subsetSumII(List<int> nums, int target) {\n  List<int> state = []; // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n  nums.sort(); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n  int start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n  List<List<int>> res = []; // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n  backtrack(state, target, nums, start, res);\n  return res;\n}\n
    subset_sum_ii.rs
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfn backtrack(\n    mut state: Vec<i32>,\n    target: i32,\n    choices: &[i32],\n    start: usize,\n    res: &mut Vec<Vec<i32>>,\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if target == 0 {\n        res.push(state);\n        return;\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\n    for i in start..choices.len() {\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\n        if target - choices[i] < 0 {\n            break;\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\n        if i > start && choices[i] == choices[i - 1] {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.push(choices[i]);\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(state.clone(), target - choices[i], choices, i, res);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        state.pop();\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfn subset_sum_ii(nums: &mut [i32], target: i32) -> Vec<Vec<i32>> {\n    let state = Vec::new(); // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    nums.sort(); // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    let start = 0; // \u904d\u5386\u8d77\u59cb\u70b9\n    let mut res = Vec::new(); // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, &mut res);\n    res\n}\n
    subset_sum_ii.c
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nvoid backtrack(int target, int *choices, int choicesSize, int start) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target == 0) {\n        for (int i = 0; i < stateSize; i++) {\n            res[resSize][i] = state[i];\n        }\n        resColSizes[resSize++] = stateSize;\n        return;\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\n    for (int i = start; i < choicesSize; i++) {\n        // \u526a\u679d\u4e00\uff1a\u82e5\u5b50\u96c6\u548c\u8d85\u8fc7 target \uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\n        if (target - choices[i] < 0) {\n            continue;\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state[stateSize] = choices[i];\n        stateSize++;\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(target - choices[i], choices, choicesSize, i + 1);\n        // \u56de\u9000\uff1a\u64a4\u9500\u9009\u62e9\uff0c\u6062\u590d\u5230\u4e4b\u524d\u7684\u72b6\u6001\n        stateSize--;\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nvoid subsetSumII(int *nums, int numsSize, int target) {\n    // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    qsort(nums, numsSize, sizeof(int), cmp);\n    // \u5f00\u59cb\u56de\u6eaf\n    backtrack(target, nums, numsSize, 0);\n}\n
    subset_sum_ii.kt
    /* \u56de\u6eaf\u7b97\u6cd5\uff1a\u5b50\u96c6\u548c II */\nfun backtrack(\n    state: MutableList<Int>,\n    target: Int,\n    choices: IntArray,\n    start: Int,\n    res: MutableList<List<Int>?>\n) {\n    // \u5b50\u96c6\u548c\u7b49\u4e8e target \u65f6\uff0c\u8bb0\u5f55\u89e3\n    if (target == 0) {\n        res.add(ArrayList(state))\n        return\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\n    for (i in start..<choices.size) {\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\n        if (target - choices[i] < 0) {\n            break\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\n        if (i > start && choices[i] == choices[i - 1]) {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0 target, start\n        state.add(choices[i])\n        // \u8fdb\u884c\u4e0b\u4e00\u8f6e\u9009\u62e9\n        backtrack(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\n        state.removeAt(state.size - 1)\n    }\n}\n\n/* \u6c42\u89e3\u5b50\u96c6\u548c II */\nfun subsetSumII(nums: IntArray, target: Int): List<List<Int>?> {\n    val state: MutableList<Int> = ArrayList() // \u72b6\u6001\uff08\u5b50\u96c6\uff09\n    Arrays.sort(nums) // \u5bf9 nums \u8fdb\u884c\u6392\u5e8f\n    val start = 0 // \u904d\u5386\u8d77\u59cb\u70b9\n    val res: MutableList<List<Int>?> = ArrayList() // \u7ed3\u679c\u5217\u8868\uff08\u5b50\u96c6\u5217\u8868\uff09\n    backtrack(state, target, nums, start, res)\n    return res\n}\n
    subset_sum_ii.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subset_sum_ii}\n
    subset_sum_ii.zig
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{subsetSumII}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 13-14 \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\u8bf7\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

    \u56fe 13-14 \u00a0 \u5b50\u96c6\u548c II \u56de\u6eaf\u8fc7\u7a0b

    "},{"location":"chapter_backtracking/summary/","title":"13.5 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_backtracking/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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\u6548\u7387\u66f4\u9ad8\u6216\u6548\u679c\u66f4\u597d\u7684\u89e3\u6cd5\u3002
    • \u5168\u6392\u5217\u95ee\u9898\u65e8\u5728\u641c\u7d22\u7ed9\u5b9a\u96c6\u5408\u5143\u7d20\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\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\u59cb\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\u95ee\u9898\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\u6b21\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\u6b21\u5bf9\u89d2\u7ebf\u4e0a\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_backtracking/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\u600e\u4e48\u7406\u89e3\u56de\u6eaf\u548c\u9012\u5f52\u7684\u5173\u7cfb\uff1f

    \u603b\u7684\u6765\u770b\uff0c\u56de\u6eaf\u662f\u4e00\u79cd\u201c\u7b97\u6cd5\u7b56\u7565\u201d\uff0c\u800c\u9012\u5f52\u66f4\u50cf\u662f\u4e00\u4e2a\u201c\u5de5\u5177\u201d\u3002

    • \u56de\u6eaf\u7b97\u6cd5\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u5b9e\u73b0\u3002\u7136\u800c\uff0c\u56de\u6eaf\u662f\u9012\u5f52\u7684\u5e94\u7528\u573a\u666f\u4e4b\u4e00\uff0c\u662f\u9012\u5f52\u5728\u641c\u7d22\u95ee\u9898\u4e2d\u7684\u5e94\u7528\u3002
    • \u9012\u5f52\u7684\u7ed3\u6784\u4f53\u73b0\u4e86\u201c\u5b50\u95ee\u9898\u5206\u89e3\u201d\u7684\u89e3\u9898\u8303\u5f0f\uff0c\u5e38\u7528\u4e8e\u89e3\u51b3\u5206\u6cbb\u3001\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\uff08\u8bb0\u5fc6\u5316\u9012\u5f52\uff09\u7b49\u95ee\u9898\u3002
    "},{"location":"chapter_computational_complexity/","title":"\u7b2c 2 \u7ae0 \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    Abstract

    \u590d\u6742\u5ea6\u5206\u6790\u72b9\u5982\u6d69\u701a\u7684\u7b97\u6cd5\u5b87\u5b99\u4e2d\u7684\u65f6\u7a7a\u5411\u5bfc\u3002

    \u5b83\u5e26\u9886\u6211\u4eec\u5728\u65f6\u95f4\u4e0e\u7a7a\u95f4\u8fd9\u4e24\u4e2a\u7ef4\u5ea6\u4e0a\u6df1\u5165\u63a2\u7d22\uff0c\u5bfb\u627e\u66f4\u4f18\u96c5\u7684\u89e3\u51b3\u65b9\u6848\u3002

    "},{"location":"chapter_computational_complexity/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 2.1 \u00a0 \u7b97\u6cd5\u6548\u7387\u8bc4\u4f30
    • 2.2 \u00a0 \u8fed\u4ee3\u4e0e\u9012\u5f52
    • 2.3 \u00a0 \u65f6\u95f4\u590d\u6742\u5ea6
    • 2.4 \u00a0 \u7a7a\u95f4\u590d\u6742\u5ea6
    • 2.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/","title":"2.2 \u00a0 \u8fed\u4ee3\u4e0e\u9012\u5f52","text":"

    \u5728\u7b97\u6cd5\u4e2d\uff0c\u91cd\u590d\u6267\u884c\u67d0\u4e2a\u4efb\u52a1\u662f\u5f88\u5e38\u89c1\u7684\uff0c\u5b83\u4e0e\u590d\u6742\u5ea6\u5206\u6790\u606f\u606f\u76f8\u5173\u3002\u56e0\u6b64\uff0c\u5728\u4ecb\u7ecd\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e4b\u524d\uff0c\u6211\u4eec\u5148\u6765\u4e86\u89e3\u5982\u4f55\u5728\u7a0b\u5e8f\u4e2d\u5b9e\u73b0\u91cd\u590d\u6267\u884c\u4efb\u52a1\uff0c\u5373\u4e24\u79cd\u57fa\u672c\u7684\u7a0b\u5e8f\u63a7\u5236\u7ed3\u6784\uff1a\u8fed\u4ee3\u3001\u9012\u5f52\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#221","title":"2.2.1 \u00a0 \u8fed\u4ee3","text":"

    \u300c\u8fed\u4ee3 iteration\u300d\u662f\u4e00\u79cd\u91cd\u590d\u6267\u884c\u67d0\u4e2a\u4efb\u52a1\u7684\u63a7\u5236\u7ed3\u6784\u3002\u5728\u8fed\u4ee3\u4e2d\uff0c\u7a0b\u5e8f\u4f1a\u5728\u6ee1\u8db3\u4e00\u5b9a\u7684\u6761\u4ef6\u4e0b\u91cd\u590d\u6267\u884c\u67d0\u6bb5\u4ee3\u7801\uff0c\u76f4\u5230\u8fd9\u4e2a\u6761\u4ef6\u4e0d\u518d\u6ee1\u8db3\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#1-for","title":"1. \u00a0 for \u5faa\u73af","text":"

    for \u5faa\u73af\u662f\u6700\u5e38\u89c1\u7684\u8fed\u4ee3\u5f62\u5f0f\u4e4b\u4e00\uff0c\u9002\u5408\u5728\u9884\u5148\u77e5\u9053\u8fed\u4ee3\u6b21\u6570\u65f6\u4f7f\u7528\u3002

    \u4ee5\u4e0b\u51fd\u6570\u57fa\u4e8e for \u5faa\u73af\u5b9e\u73b0\u4e86\u6c42\u548c \\(1 + 2 + \\dots + n\\) \uff0c\u6c42\u548c\u7ed3\u679c\u4f7f\u7528\u53d8\u91cf res \u8bb0\u5f55\u3002\u9700\u8981\u6ce8\u610f\u7684\u662f\uff0cPython \u4e2d range(a, b) \u5bf9\u5e94\u7684\u533a\u95f4\u662f\u201c\u5de6\u95ed\u53f3\u5f00\u201d\u7684\uff0c\u5bf9\u5e94\u7684\u904d\u5386\u8303\u56f4\u4e3a \\(a, a + 1, \\dots, b-1\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def for_loop(n: int) -> int:\n    \"\"\"for \u5faa\u73af\"\"\"\n    res = 0\n    # \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        res += i\n    return res\n
    iteration.cpp
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; ++i) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.java
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.cs
    /* for \u5faa\u73af */\nint ForLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.go
    /* for \u5faa\u73af */\nfunc forLoop(n int) int {\n    res := 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i := 1; i <= n; i++ {\n        res += i\n    }\n    return res\n}\n
    iteration.swift
    /* for \u5faa\u73af */\nfunc forLoop(n: Int) -> Int {\n    var res = 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        res += i\n    }\n    return res\n}\n
    iteration.js
    /* for \u5faa\u73af */\nfunction forLoop(n) {\n    let res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.ts
    /* for \u5faa\u73af */\nfunction forLoop(n: number): number {\n    let res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.dart
    /* for \u5faa\u73af */\nint forLoop(int n) {\n  int res = 0;\n  // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n  for (int i = 1; i <= n; i++) {\n    res += i;\n  }\n  return res;\n}\n
    iteration.rs
    /* for \u5faa\u73af */\nfn for_loop(n: i32) -> i32 {\n    let mut res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i in 1..=n {\n        res += i;\n    }\n    res\n}\n
    iteration.c
    /* for \u5faa\u73af */\nint forLoop(int n) {\n    int res = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        res += i;\n    }\n    return res;\n}\n
    iteration.kt
    /* for \u5faa\u73af */\nfun forLoop(n: Int): Int {\n    var res = 0\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        res += i\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{for_loop}\n
    iteration.zig
    // for \u5faa\u73af\nfn forLoop(n: usize) i32 {\n    var res: i32 = 0;\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for (1..n+1) |i| {\n        res = res + @as(i32, @intCast(i));\n    }\n    return res;\n} \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-1 \u662f\u8be5\u6c42\u548c\u51fd\u6570\u7684\u6d41\u7a0b\u6846\u56fe\u3002

    \u56fe 2-1 \u00a0 \u6c42\u548c\u51fd\u6570\u7684\u6d41\u7a0b\u6846\u56fe

    \u6b64\u6c42\u548c\u51fd\u6570\u7684\u64cd\u4f5c\u6570\u91cf\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u6210\u6b63\u6bd4\uff0c\u6216\u8005\u8bf4\u6210\u201c\u7ebf\u6027\u5173\u7cfb\u201d\u3002\u5b9e\u9645\u4e0a\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u63cf\u8ff0\u7684\u5c31\u662f\u8fd9\u4e2a\u201c\u7ebf\u6027\u5173\u7cfb\u201d\u3002\u76f8\u5173\u5185\u5bb9\u5c06\u4f1a\u5728\u4e0b\u4e00\u8282\u4e2d\u8be6\u7ec6\u4ecb\u7ecd\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#2-while","title":"2. \u00a0 while \u5faa\u73af","text":"

    \u4e0e for \u5faa\u73af\u7c7b\u4f3c\uff0cwhile \u5faa\u73af\u4e5f\u662f\u4e00\u79cd\u5b9e\u73b0\u8fed\u4ee3\u7684\u65b9\u6cd5\u3002\u5728 while \u5faa\u73af\u4e2d\uff0c\u7a0b\u5e8f\u6bcf\u8f6e\u90fd\u4f1a\u5148\u68c0\u67e5\u6761\u4ef6\uff0c\u5982\u679c\u6761\u4ef6\u4e3a\u771f\uff0c\u5219\u7ee7\u7eed\u6267\u884c\uff0c\u5426\u5219\u5c31\u7ed3\u675f\u5faa\u73af\u3002

    \u4e0b\u9762\u6211\u4eec\u7528 while \u5faa\u73af\u6765\u5b9e\u73b0\u6c42\u548c \\(1 + 2 + \\dots + n\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def while_loop(n: int) -> int:\n    \"\"\"while \u5faa\u73af\"\"\"\n    res = 0\n    i = 1  # \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    # \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n:\n        res += i\n        i += 1  # \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    return res\n
    iteration.cpp
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.java
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.cs
    /* while \u5faa\u73af */\nint WhileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i += 1; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.go
    /* while \u5faa\u73af */\nfunc whileLoop(n int) int {\n    res := 0\n    // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    i := 1\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    for i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n    }\n    return res\n}\n
    iteration.swift
    /* while \u5faa\u73af */\nfunc whileLoop(n: Int) -> Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n {\n        res += i\n        i += 1 // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res\n}\n
    iteration.js
    /* while \u5faa\u73af */\nfunction whileLoop(n) {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.ts
    /* while \u5faa\u73af */\nfunction whileLoop(n: number): number {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.dart
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n  int res = 0;\n  int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n  // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n  while (i <= n) {\n    res += i;\n    i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n  }\n  return res;\n}\n
    iteration.rs
    /* while \u5faa\u73af */\nfn while_loop(n: i32) -> i32 {\n    let mut res = 0;\n    let mut i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while i <= n {\n        res += i;\n        i += 1; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    res\n}\n
    iteration.c
    /* while \u5faa\u73af */\nint whileLoop(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i;\n        i++; // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res;\n}\n
    iteration.kt
    /* while \u5faa\u73af */\nfun whileLoop(n: Int): Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += i\n        i++ // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{while_loop}\n
    iteration.zig
    // while \u5faa\u73af\nfn whileLoop(n: i32) i32 {\n    var res: i32 = 0;\n    var i: i32 = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 2, ..., n-1, n\n    while (i <= n) {\n        res += @intCast(i);\n        i += 1;\n    }\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    while \u5faa\u73af\u6bd4 for \u5faa\u73af\u7684\u81ea\u7531\u5ea6\u66f4\u9ad8\u3002\u5728 while \u5faa\u73af\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u81ea\u7531\u5730\u8bbe\u8ba1\u6761\u4ef6\u53d8\u91cf\u7684\u521d\u59cb\u5316\u548c\u66f4\u65b0\u6b65\u9aa4\u3002

    \u4f8b\u5982\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u6761\u4ef6\u53d8\u91cf \\(i\\) \u6bcf\u8f6e\u8fdb\u884c\u4e24\u6b21\u66f4\u65b0\uff0c\u8fd9\u79cd\u60c5\u51b5\u5c31\u4e0d\u592a\u65b9\u4fbf\u7528 for \u5faa\u73af\u5b9e\u73b0\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def while_loop_ii(n: int) -> int:\n    \"\"\"while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09\"\"\"\n    res = 0\n    i = 1  # \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    # \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n:\n        res += i\n        # \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1\n        i *= 2\n    return res\n
    iteration.cpp
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.java
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.cs
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint WhileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1; \n        i *= 2;\n    }\n    return res;\n}\n
    iteration.go
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunc whileLoopII(n int) int {\n    res := 0\n    // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    i := 1\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    for i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n        i *= 2\n    }\n    return res\n}\n
    iteration.swift
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunc whileLoopII(n: Int) -> Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1\n        i *= 2\n    }\n    return res\n}\n
    iteration.js
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunction whileLoopII(n) {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.ts
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfunction whileLoopII(n: number): number {\n    let res = 0;\n    let i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.dart
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n  int res = 0;\n  int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n  // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n  while (i <= n) {\n    res += i;\n    // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n    i++;\n    i *= 2;\n  }\n  return res;\n}\n
    iteration.rs
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfn while_loop_ii(n: i32) -> i32 {\n    let mut res = 0;\n    let mut i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while i <= n {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1;\n        i *= 2;\n    }\n    res\n}\n
    iteration.c
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nint whileLoopII(int n) {\n    int res = 0;\n    int i = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i;\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++;\n        i *= 2;\n    }\n    return res;\n}\n
    iteration.kt
    /* while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09 */\nfun whileLoopII(n: Int): Int {\n    var res = 0\n    var i = 1 // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += i\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i++\n        i *= 2\n    }\n    return res\n}\n
    iteration.rb
    [class]{}-[func]{while_loop_ii}\n
    iteration.zig
    //  while \u5faa\u73af\uff08\u4e24\u6b21\u66f4\u65b0\uff09\nfn whileLoopII(n: i32) i32 {\n    var res: i32 = 0;\n    var i: i32 = 1; // \u521d\u59cb\u5316\u6761\u4ef6\u53d8\u91cf\n    // \u5faa\u73af\u6c42\u548c 1, 4, 10, ...\n    while (i <= n) {\n        res += @intCast(i);\n        // \u66f4\u65b0\u6761\u4ef6\u53d8\u91cf\n        i += 1;\n        i *= 2;\n    }\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u603b\u7684\u6765\u8bf4\uff0cfor \u5faa\u73af\u7684\u4ee3\u7801\u66f4\u52a0\u7d27\u51d1\uff0cwhile \u5faa\u73af\u66f4\u52a0\u7075\u6d3b\uff0c\u4e24\u8005\u90fd\u53ef\u4ee5\u5b9e\u73b0\u8fed\u4ee3\u7ed3\u6784\u3002\u9009\u62e9\u4f7f\u7528\u54ea\u4e00\u4e2a\u5e94\u8be5\u6839\u636e\u7279\u5b9a\u95ee\u9898\u7684\u9700\u6c42\u6765\u51b3\u5b9a\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#3","title":"3. \u00a0 \u5d4c\u5957\u5faa\u73af","text":"

    \u6211\u4eec\u53ef\u4ee5\u5728\u4e00\u4e2a\u5faa\u73af\u7ed3\u6784\u5185\u5d4c\u5957\u53e6\u4e00\u4e2a\u5faa\u73af\u7ed3\u6784\uff0c\u4e0b\u9762\u4ee5 for \u5faa\u73af\u4e3a\u4f8b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig iteration.py
    def nested_for_loop(n: int) -> str:\n    \"\"\"\u53cc\u5c42 for \u5faa\u73af\"\"\"\n    res = \"\"\n    # \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in range(1, n + 1):\n        # \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in range(1, n + 1):\n            res += f\"({i}, {j}), \"\n    return res\n
    iteration.cpp
    /* \u53cc\u5c42 for \u5faa\u73af */\nstring nestedForLoop(int n) {\n    ostringstream res;\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; ++i) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; ++j) {\n            res << \"(\" << i << \", \" << j << \"), \";\n        }\n    }\n    return res.str();\n}\n
    iteration.java
    /* \u53cc\u5c42 for \u5faa\u73af */\nString nestedForLoop(int n) {\n    StringBuilder res = new StringBuilder();\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            res.append(\"(\" + i + \", \" + j + \"), \");\n        }\n    }\n    return res.toString();\n}\n
    iteration.cs
    /* \u53cc\u5c42 for \u5faa\u73af */\nstring NestedForLoop(int n) {\n    StringBuilder res = new();\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            res.Append($\"({i}, {j}), \");\n        }\n    }\n    return res.ToString();\n}\n
    iteration.go
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunc nestedForLoop(n int) string {\n    res := \"\"\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i := 1; i <= n; i++ {\n        for j := 1; j <= n; j++ {\n            // \u5faa\u73af j = 1, 2, ..., n-1, n\n            res += fmt.Sprintf(\"(%d, %d), \", i, j)\n        }\n    }\n    return res\n}\n
    iteration.swift
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunc nestedForLoop(n: Int) -> String {\n    var res = \"\"\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in 1 ... n {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in 1 ... n {\n            res.append(\"(\\(i), \\(j)), \")\n        }\n    }\n    return res\n}\n
    iteration.js
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunction nestedForLoop(n) {\n    let res = '';\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (let j = 1; j <= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n
    iteration.ts
    /* \u53cc\u5c42 for \u5faa\u73af */\nfunction nestedForLoop(n: number): string {\n    let res = '';\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (let i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (let j = 1; j <= n; j++) {\n            res += `(${i}, ${j}), `;\n        }\n    }\n    return res;\n}\n
    iteration.dart
    /* \u53cc\u5c42 for \u5faa\u73af */\nString nestedForLoop(int n) {\n  String res = \"\";\n  // \u5faa\u73af i = 1, 2, ..., n-1, n\n  for (int i = 1; i <= n; i++) {\n    // \u5faa\u73af j = 1, 2, ..., n-1, n\n    for (int j = 1; j <= n; j++) {\n      res += \"($i, $j), \";\n    }\n  }\n  return res;\n}\n
    iteration.rs
    /* \u53cc\u5c42 for \u5faa\u73af */\nfn nested_for_loop(n: i32) -> String {\n    let mut res = vec![];\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for i in 1..=n {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for j in 1..=n {\n            res.push(format!(\"({}, {}), \", i, j));\n        }\n    }\n    res.join(\"\")\n}\n
    iteration.c
    /* \u53cc\u5c42 for \u5faa\u73af */\nchar *nestedForLoop(int n) {\n    // n * n \u4e3a\u5bf9\u5e94\u70b9\u6570\u91cf\uff0c\"(i, j), \" \u5bf9\u5e94\u5b57\u7b26\u4e32\u957f\u6700\u5927\u4e3a 6+10*2\uff0c\u52a0\u4e0a\u6700\u540e\u4e00\u4e2a\u7a7a\u5b57\u7b26 \\0 \u7684\u989d\u5916\u7a7a\u95f4\n    int size = n * n * 26 + 1;\n    char *res = malloc(size * sizeof(char));\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (int i = 1; i <= n; i++) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (int j = 1; j <= n; j++) {\n            char tmp[26];\n            snprintf(tmp, sizeof(tmp), \"(%d, %d), \", i, j);\n            strncat(res, tmp, size - strlen(res) - 1);\n        }\n    }\n    return res;\n}\n
    iteration.kt
    /* \u53cc\u5c42 for \u5faa\u73af */\nfun nestedForLoop(n: Int): String {\n    val res = StringBuilder()\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (i in 1..n) {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (j in 1..n) {\n            res.append(\" ($i, $j), \")\n        }\n    }\n    return res.toString()\n}\n
    iteration.rb
    [class]{}-[func]{nested_for_loop}\n
    iteration.zig
    // \u53cc\u5c42 for \u5faa\u73af\nfn nestedForLoop(allocator: Allocator, n: usize) ![]const u8 {\n    var res = std.ArrayList(u8).init(allocator);\n    defer res.deinit();\n    var buffer: [20]u8 = undefined;\n    // \u5faa\u73af i = 1, 2, ..., n-1, n\n    for (1..n+1) |i| {\n        // \u5faa\u73af j = 1, 2, ..., n-1, n\n        for (1..n+1) |j| {\n            var _str = try std.fmt.bufPrint(&buffer, \"({d}, {d}), \", .{i, j});\n            try res.appendSlice(_str);\n        }\n    }\n    return res.toOwnedSlice();\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-2 \u662f\u8be5\u5d4c\u5957\u5faa\u73af\u7684\u6d41\u7a0b\u6846\u56fe\u3002

    \u56fe 2-2 \u00a0 \u5d4c\u5957\u5faa\u73af\u7684\u6d41\u7a0b\u6846\u56fe

    \u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u51fd\u6570\u7684\u64cd\u4f5c\u6570\u91cf\u4e0e \\(n^2\\) \u6210\u6b63\u6bd4\uff0c\u6216\u8005\u8bf4\u7b97\u6cd5\u8fd0\u884c\u65f6\u95f4\u548c\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u6210\u201c\u5e73\u65b9\u5173\u7cfb\u201d\u3002

    \u6211\u4eec\u53ef\u4ee5\u7ee7\u7eed\u6dfb\u52a0\u5d4c\u5957\u5faa\u73af\uff0c\u6bcf\u4e00\u6b21\u5d4c\u5957\u90fd\u662f\u4e00\u6b21\u201c\u5347\u7ef4\u201d\uff0c\u5c06\u4f1a\u4f7f\u65f6\u95f4\u590d\u6742\u5ea6\u63d0\u9ad8\u81f3\u201c\u7acb\u65b9\u5173\u7cfb\u201d\u201c\u56db\u6b21\u65b9\u5173\u7cfb\u201d\uff0c\u4ee5\u6b64\u7c7b\u63a8\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#222","title":"2.2.2 \u00a0 \u9012\u5f52","text":"

    \u300c\u9012\u5f52 recursion\u300d\u662f\u4e00\u79cd\u7b97\u6cd5\u7b56\u7565\uff0c\u901a\u8fc7\u51fd\u6570\u8c03\u7528\u81ea\u8eab\u6765\u89e3\u51b3\u95ee\u9898\u3002\u5b83\u4e3b\u8981\u5305\u542b\u4e24\u4e2a\u9636\u6bb5\u3002

    1. \u9012\uff1a\u7a0b\u5e8f\u4e0d\u65ad\u6df1\u5165\u5730\u8c03\u7528\u81ea\u8eab\uff0c\u901a\u5e38\u4f20\u5165\u66f4\u5c0f\u6216\u66f4\u7b80\u5316\u7684\u53c2\u6570\uff0c\u76f4\u5230\u8fbe\u5230\u201c\u7ec8\u6b62\u6761\u4ef6\u201d\u3002
    2. \u5f52\uff1a\u89e6\u53d1\u201c\u7ec8\u6b62\u6761\u4ef6\u201d\u540e\uff0c\u7a0b\u5e8f\u4ece\u6700\u6df1\u5c42\u7684\u9012\u5f52\u51fd\u6570\u5f00\u59cb\u9010\u5c42\u8fd4\u56de\uff0c\u6c47\u805a\u6bcf\u4e00\u5c42\u7684\u7ed3\u679c\u3002

    \u800c\u4ece\u5b9e\u73b0\u7684\u89d2\u5ea6\u770b\uff0c\u9012\u5f52\u4ee3\u7801\u4e3b\u8981\u5305\u542b\u4e09\u4e2a\u8981\u7d20\u3002

    1. \u7ec8\u6b62\u6761\u4ef6\uff1a\u7528\u4e8e\u51b3\u5b9a\u4ec0\u4e48\u65f6\u5019\u7531\u201c\u9012\u201d\u8f6c\u201c\u5f52\u201d\u3002
    2. \u9012\u5f52\u8c03\u7528\uff1a\u5bf9\u5e94\u201c\u9012\u201d\uff0c\u51fd\u6570\u8c03\u7528\u81ea\u8eab\uff0c\u901a\u5e38\u8f93\u5165\u66f4\u5c0f\u6216\u66f4\u7b80\u5316\u7684\u53c2\u6570\u3002
    3. \u8fd4\u56de\u7ed3\u679c\uff1a\u5bf9\u5e94\u201c\u5f52\u201d\uff0c\u5c06\u5f53\u524d\u9012\u5f52\u5c42\u7ea7\u7684\u7ed3\u679c\u8fd4\u56de\u81f3\u4e0a\u4e00\u5c42\u3002

    \u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff0c\u6211\u4eec\u53ea\u9700\u8c03\u7528\u51fd\u6570 recur(n) \uff0c\u5c31\u53ef\u4ee5\u5b8c\u6210 \\(1 + 2 + \\dots + n\\) \u7684\u8ba1\u7b97\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def recur(n: int) -> int:\n    \"\"\"\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if n == 1:\n        return 1\n    # \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    res = recur(n - 1)\n    # \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n
    recursion.cpp
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.java
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.cs
    /* \u9012\u5f52 */\nint Recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = Recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.go
    /* \u9012\u5f52 */\nfunc recur(n int) int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    res := recur(n - 1)\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.swift
    /* \u9012\u5f52 */\nfunc recur(n: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    let res = recur(n: n - 1)\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.js
    /* \u9012\u5f52 */\nfunction recur(n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 1) return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    const res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.ts
    /* \u9012\u5f52 */\nfunction recur(n: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 1) return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    const res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.dart
    /* \u9012\u5f52 */\nint recur(int n) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (n == 1) return 1;\n  // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n  int res = recur(n - 1);\n  // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n  return n + res;\n}\n
    recursion.rs
    /* \u9012\u5f52 */\nfn recur(n: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 1 {\n        return 1;\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    let res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    n + res\n}\n
    recursion.c
    /* \u9012\u5f52 */\nint recur(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    int res = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    recursion.kt
    /* \u9012\u5f52 */\nfun recur(n: Int): Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1)\n        return 1\n    // \u9012: \u9012\u5f52\u8c03\u7528\n    val res = recur(n - 1)\n    // \u5f52: \u8fd4\u56de\u7ed3\u679c\n    return n + res\n}\n
    recursion.rb
    [class]{}-[func]{recur}\n
    recursion.zig
    // \u9012\u5f52\u51fd\u6570\nfn recur(n: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 1) {\n        return 1;\n    }\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    var res: i32 = recur(n - 1);\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    return n + res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-3 \u5c55\u793a\u4e86\u8be5\u51fd\u6570\u7684\u9012\u5f52\u8fc7\u7a0b\u3002

    \u56fe 2-3 \u00a0 \u6c42\u548c\u51fd\u6570\u7684\u9012\u5f52\u8fc7\u7a0b

    \u867d\u7136\u4ece\u8ba1\u7b97\u89d2\u5ea6\u770b\uff0c\u8fed\u4ee3\u4e0e\u9012\u5f52\u53ef\u4ee5\u5f97\u5230\u76f8\u540c\u7684\u7ed3\u679c\uff0c\u4f46\u5b83\u4eec\u4ee3\u8868\u4e86\u4e24\u79cd\u5b8c\u5168\u4e0d\u540c\u7684\u601d\u8003\u548c\u89e3\u51b3\u95ee\u9898\u7684\u8303\u5f0f\u3002

    • \u8fed\u4ee3\uff1a\u201c\u81ea\u4e0b\u800c\u4e0a\u201d\u5730\u89e3\u51b3\u95ee\u9898\u3002\u4ece\u6700\u57fa\u7840\u7684\u6b65\u9aa4\u5f00\u59cb\uff0c\u7136\u540e\u4e0d\u65ad\u91cd\u590d\u6216\u7d2f\u52a0\u8fd9\u4e9b\u6b65\u9aa4\uff0c\u76f4\u5230\u4efb\u52a1\u5b8c\u6210\u3002
    • \u9012\u5f52\uff1a\u201c\u81ea\u4e0a\u800c\u4e0b\u201d\u5730\u89e3\u51b3\u95ee\u9898\u3002\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\uff0c\u8fd9\u4e9b\u5b50\u95ee\u9898\u548c\u539f\u95ee\u9898\u5177\u6709\u76f8\u540c\u7684\u5f62\u5f0f\u3002\u63a5\u4e0b\u6765\u5c06\u5b50\u95ee\u9898\u7ee7\u7eed\u5206\u89e3\u4e3a\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\uff0c\u76f4\u5230\u57fa\u672c\u60c5\u51b5\u65f6\u505c\u6b62\uff08\u57fa\u672c\u60c5\u51b5\u7684\u89e3\u662f\u5df2\u77e5\u7684\uff09\u3002

    \u4ee5\u4e0a\u8ff0\u6c42\u548c\u51fd\u6570\u4e3a\u4f8b\uff0c\u8bbe\u95ee\u9898 \\(f(n) = 1 + 2 + \\dots + n\\) \u3002

    • \u8fed\u4ee3\uff1a\u5728\u5faa\u73af\u4e2d\u6a21\u62df\u6c42\u548c\u8fc7\u7a0b\uff0c\u4ece \\(1\\) \u904d\u5386\u5230 \\(n\\) \uff0c\u6bcf\u8f6e\u6267\u884c\u6c42\u548c\u64cd\u4f5c\uff0c\u5373\u53ef\u6c42\u5f97 \\(f(n)\\) \u3002
    • \u9012\u5f52\uff1a\u5c06\u95ee\u9898\u5206\u89e3\u4e3a\u5b50\u95ee\u9898 \\(f(n) = n + f(n-1)\\) \uff0c\u4e0d\u65ad\uff08\u9012\u5f52\u5730\uff09\u5206\u89e3\u4e0b\u53bb\uff0c\u76f4\u81f3\u57fa\u672c\u60c5\u51b5 \\(f(1) = 1\\) \u65f6\u7ec8\u6b62\u3002
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#1","title":"1. \u00a0 \u8c03\u7528\u6808","text":"

    \u9012\u5f52\u51fd\u6570\u6bcf\u6b21\u8c03\u7528\u81ea\u8eab\u65f6\uff0c\u7cfb\u7edf\u90fd\u4f1a\u4e3a\u65b0\u5f00\u542f\u7684\u51fd\u6570\u5206\u914d\u5185\u5b58\uff0c\u4ee5\u5b58\u50a8\u5c40\u90e8\u53d8\u91cf\u3001\u8c03\u7528\u5730\u5740\u548c\u5176\u4ed6\u4fe1\u606f\u7b49\u3002\u8fd9\u5c06\u5bfc\u81f4\u4e24\u65b9\u9762\u7684\u7ed3\u679c\u3002

    • \u51fd\u6570\u7684\u4e0a\u4e0b\u6587\u6570\u636e\u90fd\u5b58\u50a8\u5728\u79f0\u4e3a\u201c\u6808\u5e27\u7a7a\u95f4\u201d\u7684\u5185\u5b58\u533a\u57df\u4e2d\uff0c\u76f4\u81f3\u51fd\u6570\u8fd4\u56de\u540e\u624d\u4f1a\u88ab\u91ca\u653e\u3002\u56e0\u6b64\uff0c\u9012\u5f52\u901a\u5e38\u6bd4\u8fed\u4ee3\u66f4\u52a0\u8017\u8d39\u5185\u5b58\u7a7a\u95f4\u3002
    • \u9012\u5f52\u8c03\u7528\u51fd\u6570\u4f1a\u4ea7\u751f\u989d\u5916\u7684\u5f00\u9500\u3002\u56e0\u6b64\u9012\u5f52\u901a\u5e38\u6bd4\u5faa\u73af\u7684\u65f6\u95f4\u6548\u7387\u66f4\u4f4e\u3002

    \u5982\u56fe 2-4 \u6240\u793a\uff0c\u5728\u89e6\u53d1\u7ec8\u6b62\u6761\u4ef6\u524d\uff0c\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684\u9012\u5f52\u51fd\u6570\uff0c\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \u3002

    \u56fe 2-4 \u00a0 \u9012\u5f52\u8c03\u7528\u6df1\u5ea6

    \u5728\u5b9e\u9645\u4e2d\uff0c\u7f16\u7a0b\u8bed\u8a00\u5141\u8bb8\u7684\u9012\u5f52\u6df1\u5ea6\u901a\u5e38\u662f\u6709\u9650\u7684\uff0c\u8fc7\u6df1\u7684\u9012\u5f52\u53ef\u80fd\u5bfc\u81f4\u6808\u6ea2\u51fa\u9519\u8bef\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#2","title":"2. \u00a0 \u5c3e\u9012\u5f52","text":"

    \u6709\u8da3\u7684\u662f\uff0c\u5982\u679c\u51fd\u6570\u5728\u8fd4\u56de\u524d\u7684\u6700\u540e\u4e00\u6b65\u624d\u8fdb\u884c\u9012\u5f52\u8c03\u7528\uff0c\u5219\u8be5\u51fd\u6570\u53ef\u4ee5\u88ab\u7f16\u8bd1\u5668\u6216\u89e3\u91ca\u5668\u4f18\u5316\uff0c\u4f7f\u5176\u5728\u7a7a\u95f4\u6548\u7387\u4e0a\u4e0e\u8fed\u4ee3\u76f8\u5f53\u3002\u8fd9\u79cd\u60c5\u51b5\u88ab\u79f0\u4e3a\u300c\u5c3e\u9012\u5f52 tail recursion\u300d\u3002

    • \u666e\u901a\u9012\u5f52\uff1a\u5f53\u51fd\u6570\u8fd4\u56de\u5230\u4e0a\u4e00\u5c42\u7ea7\u7684\u51fd\u6570\u540e\uff0c\u9700\u8981\u7ee7\u7eed\u6267\u884c\u4ee3\u7801\uff0c\u56e0\u6b64\u7cfb\u7edf\u9700\u8981\u4fdd\u5b58\u4e0a\u4e00\u5c42\u8c03\u7528\u7684\u4e0a\u4e0b\u6587\u3002
    • \u5c3e\u9012\u5f52\uff1a\u9012\u5f52\u8c03\u7528\u662f\u51fd\u6570\u8fd4\u56de\u524d\u7684\u6700\u540e\u4e00\u4e2a\u64cd\u4f5c\uff0c\u8fd9\u610f\u5473\u7740\u51fd\u6570\u8fd4\u56de\u5230\u4e0a\u4e00\u5c42\u7ea7\u540e\uff0c\u65e0\u987b\u7ee7\u7eed\u6267\u884c\u5176\u4ed6\u64cd\u4f5c\uff0c\u56e0\u6b64\u7cfb\u7edf\u65e0\u987b\u4fdd\u5b58\u4e0a\u4e00\u5c42\u51fd\u6570\u7684\u4e0a\u4e0b\u6587\u3002

    \u4ee5\u8ba1\u7b97 \\(1 + 2 + \\dots + n\\) \u4e3a\u4f8b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u7ed3\u679c\u53d8\u91cf res \u8bbe\u4e3a\u51fd\u6570\u53c2\u6570\uff0c\u4ece\u800c\u5b9e\u73b0\u5c3e\u9012\u5f52\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def tail_recur(n, res):\n    \"\"\"\u5c3e\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if n == 0:\n        return res\n    # \u5c3e\u9012\u5f52\u8c03\u7528\n    return tail_recur(n - 1, res + n)\n
    recursion.cpp
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.java
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.cs
    /* \u5c3e\u9012\u5f52 */\nint TailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return TailRecur(n - 1, res + n);\n}\n
    recursion.go
    /* \u5c3e\u9012\u5f52 */\nfunc tailRecur(n int, res int) int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n-1, res+n)\n}\n
    recursion.swift
    /* \u5c3e\u9012\u5f52 */\nfunc tailRecur(n: Int, res: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n: n - 1, res: res + n)\n}\n
    recursion.js
    /* \u5c3e\u9012\u5f52 */\nfunction tailRecur(n, res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 0) return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.ts
    /* \u5c3e\u9012\u5f52 */\nfunction tailRecur(n: number, res: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n === 0) return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.dart
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (n == 0) return res;\n  // \u5c3e\u9012\u5f52\u8c03\u7528\n  return tailRecur(n - 1, res + n);\n}\n
    recursion.rs
    /* \u5c3e\u9012\u5f52 */\nfn tail_recur(n: i32, res: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if n == 0 {\n        return res;\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    tail_recur(n - 1, res + n)\n}\n
    recursion.c
    /* \u5c3e\u9012\u5f52 */\nint tailRecur(int n, int res) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res;\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    recursion.kt
    /* \u5c3e\u9012\u5f52 */\ntailrec fun tailRecur(n: Int, res: Int): Int {\n    // \u6dfb\u52a0 tailrec \u5173\u952e\u8bcd\uff0c\u4ee5\u5f00\u542f\u5c3e\u9012\u5f52\u4f18\u5316\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0)\n        return res\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n)\n}\n
    recursion.rb
    [class]{}-[func]{tail_recur}\n
    recursion.zig
    // \u5c3e\u9012\u5f52\u51fd\u6570\nfn tailRecur(n: i32, res: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (n == 0) {\n        return res;\n    }\n    // \u5c3e\u9012\u5f52\u8c03\u7528\n    return tailRecur(n - 1, res + n);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5c3e\u9012\u5f52\u7684\u6267\u884c\u8fc7\u7a0b\u5982\u56fe 2-5 \u6240\u793a\u3002\u5bf9\u6bd4\u666e\u901a\u9012\u5f52\u548c\u5c3e\u9012\u5f52\uff0c\u4e24\u8005\u7684\u6c42\u548c\u64cd\u4f5c\u7684\u6267\u884c\u70b9\u662f\u4e0d\u540c\u7684\u3002

    • \u666e\u901a\u9012\u5f52\uff1a\u6c42\u548c\u64cd\u4f5c\u662f\u5728\u201c\u5f52\u201d\u7684\u8fc7\u7a0b\u4e2d\u6267\u884c\u7684\uff0c\u6bcf\u5c42\u8fd4\u56de\u540e\u90fd\u8981\u518d\u6267\u884c\u4e00\u6b21\u6c42\u548c\u64cd\u4f5c\u3002
    • \u5c3e\u9012\u5f52\uff1a\u6c42\u548c\u64cd\u4f5c\u662f\u5728\u201c\u9012\u201d\u7684\u8fc7\u7a0b\u4e2d\u6267\u884c\u7684\uff0c\u201c\u5f52\u201d\u7684\u8fc7\u7a0b\u53ea\u9700\u5c42\u5c42\u8fd4\u56de\u3002

    \u56fe 2-5 \u00a0 \u5c3e\u9012\u5f52\u8fc7\u7a0b

    Tip

    \u8bf7\u6ce8\u610f\uff0c\u8bb8\u591a\u7f16\u8bd1\u5668\u6216\u89e3\u91ca\u5668\u5e76\u4e0d\u652f\u6301\u5c3e\u9012\u5f52\u4f18\u5316\u3002\u4f8b\u5982\uff0cPython \u9ed8\u8ba4\u4e0d\u652f\u6301\u5c3e\u9012\u5f52\u4f18\u5316\uff0c\u56e0\u6b64\u5373\u4f7f\u51fd\u6570\u662f\u5c3e\u9012\u5f52\u5f62\u5f0f\uff0c\u4ecd\u7136\u53ef\u80fd\u4f1a\u9047\u5230\u6808\u6ea2\u51fa\u95ee\u9898\u3002

    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#3_1","title":"3. \u00a0 \u9012\u5f52\u6811","text":"

    \u5f53\u5904\u7406\u4e0e\u201c\u5206\u6cbb\u201d\u76f8\u5173\u7684\u7b97\u6cd5\u95ee\u9898\u65f6\uff0c\u9012\u5f52\u5f80\u5f80\u6bd4\u8fed\u4ee3\u7684\u601d\u8def\u66f4\u52a0\u76f4\u89c2\u3001\u4ee3\u7801\u66f4\u52a0\u6613\u8bfb\u3002\u4ee5\u201c\u6590\u6ce2\u90a3\u5951\u6570\u5217\u201d\u4e3a\u4f8b\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6590\u6ce2\u90a3\u5951\u6570\u5217 \\(0, 1, 1, 2, 3, 5, 8, 13, \\dots\\) \uff0c\u6c42\u8be5\u6570\u5217\u7684\u7b2c \\(n\\) \u4e2a\u6570\u5b57\u3002

    \u8bbe\u6590\u6ce2\u90a3\u5951\u6570\u5217\u7684\u7b2c \\(n\\) \u4e2a\u6570\u5b57\u4e3a \\(f(n)\\) \uff0c\u6613\u5f97\u4e24\u4e2a\u7ed3\u8bba\u3002

    • \u6570\u5217\u7684\u524d\u4e24\u4e2a\u6570\u5b57\u4e3a \\(f(1) = 0\\) \u548c \\(f(2) = 1\\) \u3002
    • \u6570\u5217\u4e2d\u7684\u6bcf\u4e2a\u6570\u5b57\u662f\u524d\u4e24\u4e2a\u6570\u5b57\u7684\u548c\uff0c\u5373 \\(f(n) = f(n - 1) + f(n - 2)\\) \u3002

    \u6309\u7167\u9012\u63a8\u5173\u7cfb\u8fdb\u884c\u9012\u5f52\u8c03\u7528\uff0c\u5c06\u524d\u4e24\u4e2a\u6570\u5b57\u4f5c\u4e3a\u7ec8\u6b62\u6761\u4ef6\uff0c\u4fbf\u53ef\u5199\u51fa\u9012\u5f52\u4ee3\u7801\u3002\u8c03\u7528 fib(n) \u5373\u53ef\u5f97\u5230\u6590\u6ce2\u90a3\u5951\u6570\u5217\u7684\u7b2c \\(n\\) \u4e2a\u6570\u5b57\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def fib(n: int) -> int:\n    \"\"\"\u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 or n == 2:\n        return n - 1\n    # \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    res = fib(n - 1) + fib(n - 2)\n    # \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n
    recursion.cpp
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.java
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.cs
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint Fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = Fib(n - 1) + Fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.go
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunc fib(n int) int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    res := fib(n-1) + fib(n-2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.swift
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunc fib(n: Int) -> Int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    let res = fib(n: n - 1) + fib(n: n - 2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.js
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunction fib(n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.ts
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfunction fib(n: number): number {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n === 1 || n === 2) return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    const res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.dart
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n  // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n  if (n == 1 || n == 2) return n - 1;\n  // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n  int res = fib(n - 1) + fib(n - 2);\n  // \u8fd4\u56de\u7ed3\u679c f(n)\n  return res;\n}\n
    recursion.rs
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfn fib(n: i32) -> i32 {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if n == 1 || n == 2 {\n        return n - 1;\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    let res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c\n    res\n}\n
    recursion.c
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nint fib(int n) {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1;\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    int res = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    recursion.kt
    /* \u6590\u6ce2\u90a3\u5951\u6570\u5217\uff1a\u9012\u5f52 */\nfun fib(n: Int): Int {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 || n == 2)\n        return n - 1\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    val res = fib(n - 1) + fib(n - 2)\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res\n}\n
    recursion.rb
    [class]{}-[func]{fib}\n
    recursion.zig
    // \u6590\u6ce2\u90a3\u5951\u6570\u5217\nfn fib(n: i32) i32 {\n    // \u7ec8\u6b62\u6761\u4ef6 f(1) = 0, f(2) = 1\n    if (n == 1 or n == 2) {\n        return n - 1;\n    }\n    // \u9012\u5f52\u8c03\u7528 f(n) = f(n-1) + f(n-2)\n    var res: i32 = fib(n - 1) + fib(n - 2);\n    // \u8fd4\u56de\u7ed3\u679c f(n)\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u89c2\u5bdf\u4ee5\u4e0a\u4ee3\u7801\uff0c\u6211\u4eec\u5728\u51fd\u6570\u5185\u9012\u5f52\u8c03\u7528\u4e86\u4e24\u4e2a\u51fd\u6570\uff0c\u8fd9\u610f\u5473\u7740\u4ece\u4e00\u4e2a\u8c03\u7528\u4ea7\u751f\u4e86\u4e24\u4e2a\u8c03\u7528\u5206\u652f\u3002\u5982\u56fe 2-6 \u6240\u793a\uff0c\u8fd9\u6837\u4e0d\u65ad\u9012\u5f52\u8c03\u7528\u4e0b\u53bb\uff0c\u6700\u7ec8\u5c06\u4ea7\u751f\u4e00\u68f5\u5c42\u6570\u4e3a \\(n\\) \u7684\u300c\u9012\u5f52\u6811 recursion tree\u300d\u3002

    \u56fe 2-6 \u00a0 \u6590\u6ce2\u90a3\u5951\u6570\u5217\u7684\u9012\u5f52\u6811

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u9012\u5f52\u4f53\u73b0\u4e86\u201c\u5c06\u95ee\u9898\u5206\u89e3\u4e3a\u66f4\u5c0f\u5b50\u95ee\u9898\u201d\u7684\u601d\u7ef4\u8303\u5f0f\uff0c\u8fd9\u79cd\u5206\u6cbb\u7b56\u7565\u81f3\u5173\u91cd\u8981\u3002

    • \u4ece\u7b97\u6cd5\u89d2\u5ea6\u770b\uff0c\u641c\u7d22\u3001\u6392\u5e8f\u3001\u56de\u6eaf\u3001\u5206\u6cbb\u3001\u52a8\u6001\u89c4\u5212\u7b49\u8bb8\u591a\u91cd\u8981\u7b97\u6cd5\u7b56\u7565\u76f4\u63a5\u6216\u95f4\u63a5\u5730\u5e94\u7528\u4e86\u8fd9\u79cd\u601d\u7ef4\u65b9\u5f0f\u3002
    • \u4ece\u6570\u636e\u7ed3\u6784\u89d2\u5ea6\u770b\uff0c\u9012\u5f52\u5929\u7136\u9002\u5408\u5904\u7406\u94fe\u8868\u3001\u6811\u548c\u56fe\u7684\u76f8\u5173\u95ee\u9898\uff0c\u56e0\u4e3a\u5b83\u4eec\u975e\u5e38\u9002\u5408\u7528\u5206\u6cbb\u601d\u60f3\u8fdb\u884c\u5206\u6790\u3002
    "},{"location":"chapter_computational_complexity/iteration_and_recursion/#223","title":"2.2.3 \u00a0 \u4e24\u8005\u5bf9\u6bd4","text":"

    \u603b\u7ed3\u4ee5\u4e0a\u5185\u5bb9\uff0c\u5982\u8868 2-1 \u6240\u793a\uff0c\u8fed\u4ee3\u548c\u9012\u5f52\u5728\u5b9e\u73b0\u3001\u6027\u80fd\u548c\u9002\u7528\u6027\u4e0a\u6709\u6240\u4e0d\u540c\u3002

    \u8868 2-1 \u00a0 \u8fed\u4ee3\u4e0e\u9012\u5f52\u7279\u70b9\u5bf9\u6bd4

    \u8fed\u4ee3 \u9012\u5f52 \u5b9e\u73b0\u65b9\u5f0f \u5faa\u73af\u7ed3\u6784 \u51fd\u6570\u8c03\u7528\u81ea\u8eab \u65f6\u95f4\u6548\u7387 \u6548\u7387\u901a\u5e38\u8f83\u9ad8\uff0c\u65e0\u51fd\u6570\u8c03\u7528\u5f00\u9500 \u6bcf\u6b21\u51fd\u6570\u8c03\u7528\u90fd\u4f1a\u4ea7\u751f\u5f00\u9500 \u5185\u5b58\u4f7f\u7528 \u901a\u5e38\u4f7f\u7528\u56fa\u5b9a\u5927\u5c0f\u7684\u5185\u5b58\u7a7a\u95f4 \u7d2f\u79ef\u51fd\u6570\u8c03\u7528\u53ef\u80fd\u4f7f\u7528\u5927\u91cf\u7684\u6808\u5e27\u7a7a\u95f4 \u9002\u7528\u95ee\u9898 \u9002\u7528\u4e8e\u7b80\u5355\u5faa\u73af\u4efb\u52a1\uff0c\u4ee3\u7801\u76f4\u89c2\u3001\u53ef\u8bfb\u6027\u597d \u9002\u7528\u4e8e\u5b50\u95ee\u9898\u5206\u89e3\uff0c\u5982\u6811\u3001\u56fe\u3001\u5206\u6cbb\u3001\u56de\u6eaf\u7b49\uff0c\u4ee3\u7801\u7ed3\u6784\u7b80\u6d01\u3001\u6e05\u6670

    Tip

    \u5982\u679c\u611f\u89c9\u4ee5\u4e0b\u5185\u5bb9\u7406\u89e3\u56f0\u96be\uff0c\u53ef\u4ee5\u5728\u8bfb\u5b8c\u201c\u6808\u201d\u7ae0\u8282\u540e\u518d\u6765\u590d\u4e60\u3002

    \u90a3\u4e48\uff0c\u8fed\u4ee3\u548c\u9012\u5f52\u5177\u6709\u4ec0\u4e48\u5185\u5728\u8054\u7cfb\u5462\uff1f\u4ee5\u4e0a\u8ff0\u9012\u5f52\u51fd\u6570\u4e3a\u4f8b\uff0c\u6c42\u548c\u64cd\u4f5c\u5728\u9012\u5f52\u7684\u201c\u5f52\u201d\u9636\u6bb5\u8fdb\u884c\u3002\u8fd9\u610f\u5473\u7740\u6700\u521d\u88ab\u8c03\u7528\u7684\u51fd\u6570\u5b9e\u9645\u4e0a\u662f\u6700\u540e\u5b8c\u6210\u5176\u6c42\u548c\u64cd\u4f5c\u7684\uff0c\u8fd9\u79cd\u5de5\u4f5c\u673a\u5236\u4e0e\u6808\u7684\u201c\u5148\u5165\u540e\u51fa\u201d\u539f\u5219\u5f02\u66f2\u540c\u5de5\u3002

    \u4e8b\u5b9e\u4e0a\uff0c\u201c\u8c03\u7528\u6808\u201d\u548c\u201c\u6808\u5e27\u7a7a\u95f4\u201d\u8fd9\u7c7b\u9012\u5f52\u672f\u8bed\u5df2\u7ecf\u6697\u793a\u4e86\u9012\u5f52\u4e0e\u6808\u4e4b\u95f4\u7684\u5bc6\u5207\u5173\u7cfb\u3002

    1. \u9012\uff1a\u5f53\u51fd\u6570\u88ab\u8c03\u7528\u65f6\uff0c\u7cfb\u7edf\u4f1a\u5728\u201c\u8c03\u7528\u6808\u201d\u4e0a\u4e3a\u8be5\u51fd\u6570\u5206\u914d\u65b0\u7684\u6808\u5e27\uff0c\u7528\u4e8e\u5b58\u50a8\u51fd\u6570\u7684\u5c40\u90e8\u53d8\u91cf\u3001\u53c2\u6570\u3001\u8fd4\u56de\u5730\u5740\u7b49\u6570\u636e\u3002
    2. \u5f52\uff1a\u5f53\u51fd\u6570\u5b8c\u6210\u6267\u884c\u5e76\u8fd4\u56de\u65f6\uff0c\u5bf9\u5e94\u7684\u6808\u5e27\u4f1a\u88ab\u4ece\u201c\u8c03\u7528\u6808\u201d\u4e0a\u79fb\u9664\uff0c\u6062\u590d\u4e4b\u524d\u51fd\u6570\u7684\u6267\u884c\u73af\u5883\u3002

    \u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u8c03\u7528\u6808\u7684\u884c\u4e3a\uff0c\u4ece\u800c\u5c06\u9012\u5f52\u8f6c\u5316\u4e3a\u8fed\u4ee3\u5f62\u5f0f\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig recursion.py
    def for_loop_recur(n: int) -> int:\n    \"\"\"\u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52\"\"\"\n    # \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack = []\n    res = 0\n    # \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in range(n, 0, -1):\n        # \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.append(i)\n    # \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while stack:\n        # \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop()\n    # res = 1+2+3+...+n\n    return res\n
    recursion.cpp
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack<int> stack;\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (!stack.empty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.top();\n        stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.java
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    Stack<Integer> stack = new Stack<>();\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (!stack.isEmpty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.cs
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint ForLoopRecur(int n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    Stack<int> stack = new();\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.Push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.Count > 0) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.Pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.go
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunc forLoopRecur(n int) int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    stack := list.New()\n    res := 0\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i := n; i > 0; i-- {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.PushBack(i)\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    for stack.Len() != 0 {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.Back().Value.(int)\n        stack.Remove(stack.Back())\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.swift
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunc forLoopRecur(n: Int) -> Int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    var stack: [Int] = []\n    var res = 0\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in (1 ... n).reversed() {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.append(i)\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while !stack.isEmpty {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.removeLast()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.js
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunction forLoopRecur(n) {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    const stack = [];\n    let res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (let i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.length) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.ts
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfunction forLoopRecur(n: number): number {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808 \n    const stack: number[] = [];\n    let res: number = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (let i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (stack.length) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop();\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.dart
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n  // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n  List<int> stack = [];\n  int res = 0;\n  // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n  for (int i = n; i > 0; i--) {\n    // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n    stack.add(i);\n  }\n  // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n  while (!stack.isEmpty) {\n    // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n    res += stack.removeLast();\n  }\n  // res = 1+2+3+...+n\n  return res;\n}\n
    recursion.rs
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfn for_loop_recur(n: i32) -> i32 {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    let mut stack = Vec::new();\n    let mut res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for i in (1..=n).rev() {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack.push(i);\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while !stack.is_empty() {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop().unwrap();\n    }\n    // res = 1+2+3+...+n\n    res\n}\n
    recursion.c
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nint forLoopRecur(int n) {\n    int stack[1000]; // \u501f\u52a9\u4e00\u4e2a\u5927\u6570\u7ec4\u6765\u6a21\u62df\u6808\n    int top = -1;    // \u6808\u9876\u7d22\u5f15\n    int res = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    for (int i = n; i > 0; i--) {\n        // \u901a\u8fc7\u201c\u5165\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u9012\u201d\n        stack[1 + top++] = i;\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    while (top >= 0) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack[top--];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    recursion.kt
    /* \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52 */\nfun forLoopRecur(n: Int): Int {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    val stack = Stack<Int>()\n    var res = 0\n    // \u9012: \u9012\u5f52\u8c03\u7528\n    for (i in n downTo 0) {\n        stack.push(i)\n    }\n    // \u5f52: \u8fd4\u56de\u7ed3\u679c\n    while (stack.isNotEmpty()) {\n        // \u901a\u8fc7\u201c\u51fa\u6808\u64cd\u4f5c\u201d\u6a21\u62df\u201c\u5f52\u201d\n        res += stack.pop()\n    }\n    // res = 1+2+3+...+n\n    return res\n}\n
    recursion.rb
    [class]{}-[func]{for_loop_recur}\n
    recursion.zig
    // \u4f7f\u7528\u8fed\u4ee3\u6a21\u62df\u9012\u5f52\nfn forLoopRecur(comptime n: i32) i32 {\n    // \u4f7f\u7528\u4e00\u4e2a\u663e\u5f0f\u7684\u6808\u6765\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\n    var stack: [n]i32 = undefined;\n    var res: i32 = 0;\n    // \u9012\uff1a\u9012\u5f52\u8c03\u7528\n    var i: usize = n;\n    while (i > 0) {\n        stack[i - 1] = @intCast(i);\n        i -= 1;\n    }\n    // \u5f52\uff1a\u8fd4\u56de\u7ed3\u679c\n    var index: usize = n;\n    while (index > 0) {\n        index -= 1;\n        res += stack[index];\n    }\n    // res = 1+2+3+...+n\n    return res;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u89c2\u5bdf\u4ee5\u4e0a\u4ee3\u7801\uff0c\u5f53\u9012\u5f52\u8f6c\u5316\u4e3a\u8fed\u4ee3\u540e\uff0c\u4ee3\u7801\u53d8\u5f97\u66f4\u52a0\u590d\u6742\u4e86\u3002\u5c3d\u7ba1\u8fed\u4ee3\u548c\u9012\u5f52\u5728\u5f88\u591a\u60c5\u51b5\u4e0b\u53ef\u4ee5\u4e92\u76f8\u8f6c\u5316\uff0c\u4f46\u4e0d\u4e00\u5b9a\u503c\u5f97\u8fd9\u6837\u505a\uff0c\u6709\u4ee5\u4e0b\u4e24\u70b9\u539f\u56e0\u3002

    • \u8f6c\u5316\u540e\u7684\u4ee3\u7801\u53ef\u80fd\u66f4\u52a0\u96be\u4ee5\u7406\u89e3\uff0c\u53ef\u8bfb\u6027\u66f4\u5dee\u3002
    • \u5bf9\u4e8e\u67d0\u4e9b\u590d\u6742\u95ee\u9898\uff0c\u6a21\u62df\u7cfb\u7edf\u8c03\u7528\u6808\u7684\u884c\u4e3a\u53ef\u80fd\u975e\u5e38\u56f0\u96be\u3002

    \u603b\u4e4b\uff0c\u9009\u62e9\u8fed\u4ee3\u8fd8\u662f\u9012\u5f52\u53d6\u51b3\u4e8e\u7279\u5b9a\u95ee\u9898\u7684\u6027\u8d28\u3002\u5728\u7f16\u7a0b\u5b9e\u8df5\u4e2d\uff0c\u6743\u8861\u4e24\u8005\u7684\u4f18\u52a3\u5e76\u6839\u636e\u60c5\u5883\u9009\u62e9\u5408\u9002\u7684\u65b9\u6cd5\u81f3\u5173\u91cd\u8981\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/","title":"2.1 \u00a0 \u7b97\u6cd5\u6548\u7387\u8bc4\u4f30","text":"

    \u5728\u7b97\u6cd5\u8bbe\u8ba1\u4e2d\uff0c\u6211\u4eec\u5148\u540e\u8ffd\u6c42\u4ee5\u4e0b\u4e24\u4e2a\u5c42\u9762\u7684\u76ee\u6807\u3002

    1. \u627e\u5230\u95ee\u9898\u89e3\u6cd5\uff1a\u7b97\u6cd5\u9700\u8981\u5728\u89c4\u5b9a\u7684\u8f93\u5165\u8303\u56f4\u5185\u53ef\u9760\u5730\u6c42\u5f97\u95ee\u9898\u7684\u6b63\u786e\u89e3\u3002
    2. \u5bfb\u6c42\u6700\u4f18\u89e3\u6cd5\uff1a\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

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5728\u80fd\u591f\u89e3\u51b3\u95ee\u9898\u7684\u524d\u63d0\u4e0b\uff0c\u7b97\u6cd5\u6548\u7387\u5df2\u6210\u4e3a\u8861\u91cf\u7b97\u6cd5\u4f18\u52a3\u7684\u4e3b\u8981\u8bc4\u4ef7\u6307\u6807\uff0c\u5b83\u5305\u62ec\u4ee5\u4e0b\u4e24\u4e2a\u7ef4\u5ea6\u3002

    • \u65f6\u95f4\u6548\u7387\uff1a\u7b97\u6cd5\u8fd0\u884c\u901f\u5ea6\u7684\u5feb\u6162\u3002
    • \u7a7a\u95f4\u6548\u7387\uff1a\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\u800c\u6709\u6548\u5730\u8bc4\u4f30\u7b97\u6cd5\u6548\u7387\u81f3\u5173\u91cd\u8981\uff0c\u56e0\u4e3a\u53ea\u6709\u8fd9\u6837\uff0c\u6211\u4eec\u624d\u80fd\u5c06\u5404\u79cd\u7b97\u6cd5\u8fdb\u884c\u5bf9\u6bd4\uff0c\u8fdb\u800c\u6307\u5bfc\u7b97\u6cd5\u8bbe\u8ba1\u4e0e\u4f18\u5316\u8fc7\u7a0b\u3002

    \u6548\u7387\u8bc4\u4f30\u65b9\u6cd5\u4e3b\u8981\u5206\u4e3a\u4e24\u79cd\uff1a\u5b9e\u9645\u6d4b\u8bd5\u3001\u7406\u8bba\u4f30\u7b97\u3002

    "},{"location":"chapter_computational_complexity/performance_evaluation/#211","title":"2.1.1 \u00a0 \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\u6700\u76f4\u63a5\u7684\u65b9\u6cd5\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\u7684\u5c40\u9650\u6027\u3002

    \u4e00\u65b9\u9762\uff0c\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\u3002\u6bd4\u5982\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\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\u7edf\u8ba1\u5e73\u5747\u6548\u7387\uff0c\u800c\u8fd9\u662f\u4e0d\u73b0\u5b9e\u7684\u3002

    \u53e6\u4e00\u65b9\u9762\uff0c\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\u5728\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5c0f\u65f6\uff0c\u7b97\u6cd5 A \u7684\u8fd0\u884c\u65f6\u95f4\u6bd4\u7b97\u6cd5 B \u77ed\uff1b\u800c\u5728\u8f93\u5165\u6570\u636e\u91cf\u8f83\u5927\u65f6\uff0c\u6d4b\u8bd5\u7ed3\u679c\u53ef\u80fd\u6070\u6070\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\u800c\u8fd9\u9700\u8981\u8017\u8d39\u5927\u91cf\u7684\u8ba1\u7b97\u8d44\u6e90\u3002

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

    \u7531\u4e8e\u5b9e\u9645\u6d4b\u8bd5\u5177\u6709\u8f83\u5927\u7684\u5c40\u9650\u6027\uff0c\u56e0\u6b64\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\u6e10\u8fd1\u590d\u6742\u5ea6\u5206\u6790 asymptotic complexity analysis\u300d\uff0c\u7b80\u79f0\u300c\u590d\u6742\u5ea6\u5206\u6790\u300d\u3002

    \u590d\u6742\u5ea6\u5206\u6790\u80fd\u591f\u4f53\u73b0\u7b97\u6cd5\u8fd0\u884c\u6240\u9700\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u8d44\u6e90\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e4b\u95f4\u7684\u5173\u7cfb\u3002\u5b83\u63cf\u8ff0\u4e86\u968f\u7740\u8f93\u5165\u6570\u636e\u5927\u5c0f\u7684\u589e\u52a0\uff0c\u7b97\u6cd5\u6267\u884c\u6240\u9700\u65f6\u95f4\u548c\u7a7a\u95f4\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\u3002

    • \u201c\u65f6\u95f4\u548c\u7a7a\u95f4\u8d44\u6e90\u201d\u5206\u522b\u5bf9\u5e94\u300c\u65f6\u95f4\u590d\u6742\u5ea6 time complexity\u300d\u548c\u300c\u7a7a\u95f4\u590d\u6742\u5ea6 space complexity\u300d\u3002
    • \u201c\u968f\u7740\u8f93\u5165\u6570\u636e\u5927\u5c0f\u7684\u589e\u52a0\u201d\u610f\u5473\u7740\u590d\u6742\u5ea6\u53cd\u6620\u4e86\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u4e0e\u8f93\u5165\u6570\u636e\u4f53\u91cf\u4e4b\u95f4\u7684\u5173\u7cfb\u3002
    • \u201c\u65f6\u95f4\u548c\u7a7a\u95f4\u7684\u589e\u957f\u8d8b\u52bf\u201d\u8868\u793a\u590d\u6742\u5ea6\u5206\u6790\u5173\u6ce8\u7684\u4e0d\u662f\u8fd0\u884c\u65f6\u95f4\u6216\u5360\u7528\u7a7a\u95f4\u7684\u5177\u4f53\u503c\uff0c\u800c\u662f\u65f6\u95f4\u6216\u7a7a\u95f4\u589e\u957f\u7684\u201c\u5feb\u6162\u201d\u3002

    \u590d\u6742\u5ea6\u5206\u6790\u514b\u670d\u4e86\u5b9e\u9645\u6d4b\u8bd5\u65b9\u6cd5\u7684\u5f0a\u7aef\uff0c\u4f53\u73b0\u5728\u4ee5\u4e0b\u4e24\u4e2a\u65b9\u9762\u3002

    • \u5b83\u72ec\u7acb\u4e8e\u6d4b\u8bd5\u73af\u5883\uff0c\u5206\u6790\u7ed3\u679c\u9002\u7528\u4e8e\u6240\u6709\u8fd0\u884c\u5e73\u53f0\u3002
    • \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

    Tip

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

    \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\u4f7f\u6211\u4eec\u53ef\u4ee5\u8861\u91cf\u6267\u884c\u67d0\u4e2a\u7b97\u6cd5\u6240\u9700\u7684\u65f6\u95f4\u548c\u7a7a\u95f4\u8d44\u6e90\uff0c\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\u6700\u5148\u4ecb\u7ecd\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\u96be\u4ee5\u907f\u514d\u8981\u5206\u6790\u5176\u8fd0\u884c\u901f\u5ea6\u548c\u7a7a\u95f4\u4f7f\u7528\u60c5\u51b5\u3002

    \u7efc\u4e0a\u6240\u8ff0\uff0c\u5efa\u8bae\u4f60\u5728\u6df1\u5165\u5b66\u4e60\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u4e4b\u524d\uff0c\u5148\u5bf9\u590d\u6742\u5ea6\u5206\u6790\u5efa\u7acb\u521d\u6b65\u7684\u4e86\u89e3\uff0c\u4ee5\u4fbf\u80fd\u591f\u5b8c\u6210\u7b80\u5355\u7b97\u6cd5\u7684\u590d\u6742\u5ea6\u5206\u6790\u3002

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

    \u300c\u7a7a\u95f4\u590d\u6742\u5ea6 space complexity\u300d\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u5360\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\uff0c\u53ea\u9700\u5c06\u201c\u8fd0\u884c\u65f6\u95f4\u201d\u66ff\u6362\u4e3a\u201c\u5360\u7528\u5185\u5b58\u7a7a\u95f4\u201d\u3002

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

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

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

    \u4e00\u822c\u60c5\u51b5\u4e0b\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u7edf\u8ba1\u8303\u56f4\u662f\u201c\u6682\u5b58\u7a7a\u95f4\u201d\u52a0\u4e0a\u201c\u8f93\u51fa\u7a7a\u95f4\u201d\u3002

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

    • \u6682\u5b58\u6570\u636e\uff1a\u7528\u4e8e\u4fdd\u5b58\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u4e2d\u7684\u5404\u79cd\u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u7b49\u3002
    • \u6808\u5e27\u7a7a\u95f4\uff1a\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
    • \u6307\u4ee4\u7a7a\u95f4\uff1a\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

    \u5728\u5206\u6790\u4e00\u6bb5\u7a0b\u5e8f\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u65f6\uff0c\u6211\u4eec\u901a\u5e38\u7edf\u8ba1\u6682\u5b58\u6570\u636e\u3001\u6808\u5e27\u7a7a\u95f4\u548c\u8f93\u51fa\u6570\u636e\u4e09\u90e8\u5206\uff0c\u5982\u56fe 2-15 \u6240\u793a\u3002

    \u56fe 2-15 \u00a0 \u7b97\u6cd5\u4f7f\u7528\u7684\u76f8\u5173\u7a7a\u95f4

    \u76f8\u5173\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class Node:\n    \"\"\"\u7c7b\"\"\"\n    def __init__(self, x: int):\n        self.val: int = x              # \u8282\u70b9\u503c\n        self.next: Node | None = None  # \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n\ndef function() -> int:\n    \"\"\"\u51fd\u6570\"\"\"\n    # \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n\ndef algorithm(n) -> int:  # \u8f93\u5165\u6570\u636e\n    A = 0                 # \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff0c\u4e00\u822c\u7528\u5927\u5199\u5b57\u6bcd\u8868\u793a\uff09\n    b = 0                 # \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    node = Node(0)        # \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    c = function()        # \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return A + b + c      # \u8f93\u51fa\u6570\u636e\n
    /* \u7ed3\u6784\u4f53 */\nstruct Node {\n    int val;\n    Node *next;\n    Node(int x) : val(x), next(nullptr) {}\n};\n\n/* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nint algorithm(int n) {        // \u8f93\u5165\u6570\u636e\n    const int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    int b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    Node* node = new Node(0); // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    int c = func();           // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n    int val;\n    Node next;\n    Node(int x) { val = x; }\n}\n\n/* \u51fd\u6570 */\nint function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nint algorithm(int n) {        // \u8f93\u5165\u6570\u636e\n    final int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    int b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    Node node = new Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    int c = function();       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node(int x) {\n    int val = x;\n    Node next;\n}\n\n/* \u51fd\u6570 */\nint Function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nint Algorithm(int n) {        // \u8f93\u5165\u6570\u636e\n    const int a = 0;          // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    int b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    Node node = new(0);       // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    int c = Function();       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7ed3\u6784\u4f53 */\ntype node struct {\n    val  int\n    next *node\n}\n\n/* \u521b\u5efa node \u7ed3\u6784\u4f53  */\nfunc newNode(val int) *node {\n    return &node{val: val}\n}\n\n/* \u51fd\u6570 */\nfunc function() int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\nfunc algorithm(n int) int { // \u8f93\u5165\u6570\u636e\n    const a = 0             // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    b := 0                  // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    newNode(0)              // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    c := function()         // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c        // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n    var val: Int\n    var next: Node?\n\n    init(x: Int) {\n        val = x\n    }\n}\n\n/* \u51fd\u6570 */\nfunc function() -> Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\nfunc algorithm(n: Int) -> Int { // \u8f93\u5165\u6570\u636e\n    let a = 0             // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    var b = 0             // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    let node = Node(x: 0) // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    let c = function()    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c      // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n    val;\n    next;\n    constructor(val) {\n        this.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\n        this.next = null;                       // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n\n/* \u51fd\u6570 */\nfunction constFunc() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\nfunction algorithm(n) {       // \u8f93\u5165\u6570\u636e\n    const a = 0;              // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    let b = 0;                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    const node = new Node(0); // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    const c = constFunc();    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;         // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n    val: number;\n    next: Node | null;\n    constructor(val?: number) {\n        this.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\n        this.next = null;                       // \u6307\u5411\u4e0b\u4e00\u8282\u70b9\u7684\u5f15\u7528\n    }\n}\n\n/* \u51fd\u6570 */\nfunction constFunc(): number {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\nfunction algorithm(n: number): number { // \u8f93\u5165\u6570\u636e\n    const a = 0;                        // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    let b = 0;                          // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    const node = new Node(0);           // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    const c = constFunc();              // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;                   // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node {\n  int val;\n  Node next;\n  Node(this.val, [this.next]);\n}\n\n/* \u51fd\u6570 */\nint function() {\n  // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n  return 0;\n}\n\nint algorithm(int n) {  // \u8f93\u5165\u6570\u636e\n  const int a = 0;      // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n  int b = 0;            // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n  Node node = Node(0);  // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n  int c = function();   // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n  return a + b + c;     // \u8f93\u51fa\u6570\u636e\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* \u7ed3\u6784\u4f53 */\nstruct Node {\n    val: i32,\n    next: Option<Rc<RefCell<Node>>>,\n}\n\n/* \u521b\u5efa Node \u7ed3\u6784\u4f53 */\nimpl Node {\n    fn new(val: i32) -> Self {\n        Self { val: val, next: None }\n    }\n}\n\n/* \u51fd\u6570 */\nfn function() -> i32 {      \n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nfn algorithm(n: i32) -> i32 {       // \u8f93\u5165\u6570\u636e\n    const a: i32 = 0;               // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    let mut b = 0;                  // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    let node = Node::new(0);        // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    let c = function();             // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;               // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0;\n}\n\nint algorithm(int n) { // \u8f93\u5165\u6570\u636e\n    const int a = 0;   // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    int b = 0;         // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    int c = func();    // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c;  // \u8f93\u51fa\u6570\u636e\n}\n
    /* \u7c7b */\nclass Node(var _val: Int) {\n    var next: Node? = null\n}\n\n/* \u51fd\u6570 */\nfun function(): Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\nfun algorithm(n: Int): Int { // \u8f93\u5165\u6570\u636e\n    val a = 0                // \u6682\u5b58\u6570\u636e\uff08\u5e38\u91cf\uff09\n    var b = 0                // \u6682\u5b58\u6570\u636e\uff08\u53d8\u91cf\uff09\n    val node = Node(0)       // \u6682\u5b58\u6570\u636e\uff08\u5bf9\u8c61\uff09\n    val c = function()       // \u6808\u5e27\u7a7a\u95f4\uff08\u8c03\u7528\u51fd\u6570\uff09\n    return a + b + c         // \u8f93\u51fa\u6570\u636e\n}\n
    \n
    \n
    "},{"location":"chapter_computational_complexity/space_complexity/#242","title":"2.4.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\u9700\u5c06\u7edf\u8ba1\u5bf9\u8c61\u4ece\u201c\u64cd\u4f5c\u6570\u91cf\u201d\u8f6c\u4e3a\u201c\u4f7f\u7528\u7a7a\u95f4\u5927\u5c0f\u201d\u3002

    \u800c\u4e0e\u65f6\u95f4\u590d\u6742\u5ea6\u4e0d\u540c\u7684\u662f\uff0c\u6211\u4eec\u901a\u5e38\u53ea\u5173\u6ce8\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u3002\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

    \u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff0c\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e2d\u7684\u201c\u6700\u5dee\u201d\u6709\u4e24\u5c42\u542b\u4e49\u3002

    1. \u4ee5\u6700\u5dee\u8f93\u5165\u6570\u636e\u4e3a\u51c6\uff1a\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\uff0c\u56e0\u6b64\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002
    2. \u4ee5\u7b97\u6cd5\u8fd0\u884c\u4e2d\u7684\u5cf0\u503c\u5185\u5b58\u4e3a\u51c6\uff1a\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\uff0c\u56e0\u6b64\u6700\u5dee\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def algorithm(n: int):\n    a = 0               # O(1)\n    b = [0] * 10000     # O(1)\n    if n > 10:\n        nums = [0] * n  # O(n)\n
    void algorithm(int n) {\n    int a = 0;               // O(1)\n    vector<int> b(10000);    // O(1)\n    if (n > 10)\n        vector<int> nums(n); // O(n)\n}\n
    void algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n > 10)\n        int[] nums = new int[n]; // O(n)\n}\n
    void Algorithm(int n) {\n    int a = 0;                   // O(1)\n    int[] b = new int[10000];    // O(1)\n    if (n > 10) {\n        int[] nums = new int[n]; // O(n)\n    }\n}\n
    func algorithm(n int) {\n    a := 0                      // O(1)\n    b := make([]int, 10000)     // O(1)\n    var nums []int\n    if n > 10 {\n        nums := make([]int, n)  // O(n)\n    }\n    fmt.Println(a, b, nums)\n}\n
    func algorithm(n: Int) {\n    let a = 0 // O(1)\n    let b = Array(repeating: 0, count: 10000) // O(1)\n    if n > 10 {\n        let nums = Array(repeating: 0, count: n) // O(n)\n    }\n}\n
    function algorithm(n) {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n > 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n
    function algorithm(n: number): void {\n    const a = 0;                   // O(1)\n    const b = new Array(10000);    // O(1)\n    if (n > 10) {\n        const nums = new Array(n); // O(n)\n    }\n}\n
    void algorithm(int n) {\n  int a = 0;                            // O(1)\n  List<int> b = List.filled(10000, 0);  // O(1)\n  if (n > 10) {\n    List<int> nums = List.filled(n, 0); // O(n)\n  }\n}\n
    fn algorithm(n: i32) {\n    let a = 0;                              // O(1)\n    let b = [0; 10000];                     // O(1)\n    if n > 10 {\n        let nums = vec![0; n as usize];     // O(n)\n    }\n}\n
    void algorithm(int n) {\n    int a = 0;               // O(1)\n    int b[10000];            // O(1)\n    if (n > 10)\n        int nums[n] = {0};   // O(n)\n}\n
    fun algorithm(n: Int) {\n    val a = 0                    // O(1)\n    val b = IntArray(10000)      // O(1)\n    if (n > 10) {\n        val nums = IntArray(n)   // O(n)\n    }\n}\n
    \n
    \n

    \u5728\u9012\u5f52\u51fd\u6570\u4e2d\uff0c\u9700\u8981\u6ce8\u610f\u7edf\u8ba1\u6808\u5e27\u7a7a\u95f4\u3002\u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def function() -> int:\n    # \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n\ndef loop(n: int):\n    \"\"\"\u5faa\u73af\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(1)\"\"\"\n    for _ in range(n):\n        function()\n\ndef recur(n: int):\n    \"\"\"\u9012\u5f52\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\"\"\"\n    if n == 1:\n        return\n    return recur(n - 1)\n
    int func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    int function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        function();\n    }\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    int Function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid Loop(int n) {\n    for (int i = 0; i < n; i++) {\n        Function();\n    }\n}\n/* \u9012\u5f52 O(n) */\nint Recur(int n) {\n    if (n == 1) return 1;\n    return Recur(n - 1);\n}\n
    func function() int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5faa\u73af O(1) */\nfunc loop(n int) {\n    for i := 0; i < n; i++ {\n        function()\n    }\n}\n\n/* \u9012\u5f52 O(n) */\nfunc recur(n int) {\n    if n == 1 {\n        return\n    }\n    recur(n - 1)\n}\n
    @discardableResult\nfunc function() -> Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5faa\u73af O(1) */\nfunc loop(n: Int) {\n    for _ in 0 ..< n {\n        function()\n    }\n}\n\n/* \u9012\u5f52 O(n) */\nfunc recur(n: Int) {\n    if n == 1 {\n        return\n    }\n    recur(n: n - 1)\n}\n
    function constFunc() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nfunction loop(n) {\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n/* \u9012\u5f52 O(n) */\nfunction recur(n) {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n
    function constFunc(): number {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nfunction loop(n: number): void {\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n/* \u9012\u5f52 O(n) */\nfunction recur(n: number): void {\n    if (n === 1) return;\n    return recur(n - 1);\n}\n
    int function() {\n  // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n  return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\n  for (int i = 0; i < n; i++) {\n    function();\n  }\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\n  if (n == 1) return;\n  return recur(n - 1);\n}\n
    fn function() -> i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nfn loop(n: i32) {\n    for i in 0..n {\n        function();\n    }\n}\n/* \u9012\u5f52 O(n) */\nfn recur(n: i32) {\n    if n == 1 {\n        return;\n    }\n    recur(n - 1);\n}\n
    int func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n/* \u5faa\u73af O(1) */\nvoid loop(int n) {\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n/* \u9012\u5f52 O(n) */\nvoid recur(int n) {\n    if (n == 1) return;\n    return recur(n - 1);\n}\n
    fun function(): Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n/* \u5faa\u73af O(1) */\nfun loop(n: Int) {\n    for (i in 0..<n) {\n        function()\n    }\n}\n/* \u9012\u5f52 O(n) */\nfun recur(n: Int) {\n    if (n == 1) return\n    return recur(n - 1)\n}\n
    \n
    \n

    \u51fd\u6570 loop() \u548c recur() \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n)\\) \uff0c\u4f46\u7a7a\u95f4\u590d\u6742\u5ea6\u4e0d\u540c\u3002

    • \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
    • \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
    "},{"location":"chapter_computational_complexity/space_complexity/#243","title":"2.4.3 \u00a0 \u5e38\u89c1\u7c7b\u578b","text":"

    \u8bbe\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff0c\u56fe 2-16 \u5c55\u793a\u4e86\u5e38\u89c1\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u7c7b\u578b\uff08\u4ece\u4f4e\u5230\u9ad8\u6392\u5217\uff09\u3002

    \\[ \\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} \\]

    \u56fe 2-16 \u00a0 \u5e38\u89c1\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u7c7b\u578b

    "},{"location":"chapter_computational_complexity/space_complexity/#1-o1","title":"1. \u00a0 \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\u56e0\u6b64\u4e0d\u4f1a\u7d2f\u79ef\u5360\u7528\u7a7a\u95f4\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def function() -> int:\n    \"\"\"\u51fd\u6570\"\"\"\n    # \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n\ndef constant(n: int):\n    \"\"\"\u5e38\u6570\u9636\"\"\"\n    # \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    a = 0\n    nums = [0] * 10000\n    node = ListNode(0)\n    # \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in range(n):\n        c = 0\n    # \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in range(n):\n        function()\n
    space_complexity.cpp
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const int a = 0;\n    int b = 0;\n    vector<int> nums(10000);\n    ListNode node(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n
    space_complexity.java
    /* \u51fd\u6570 */\nint function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    final int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        function();\n    }\n}\n
    space_complexity.cs
    /* \u51fd\u6570 */\nint Function() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid Constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    int a = 0;\n    int b = 0;\n    int[] nums = new int[10000];\n    ListNode node = new(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        Function();\n    }\n}\n
    space_complexity.go
    /* \u51fd\u6570 */\nfunc function() int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c...\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfunc spaceConstant(n int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0\n    b := 0\n    nums := make([]int, 10000)\n    node := newNode(0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    var c int\n    for i := 0; i < n; i++ {\n        c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for i := 0; i < n; i++ {\n        function()\n    }\n    b += 0\n    c += 0\n    nums[0] = 0\n    node.val = 0\n}\n
    space_complexity.swift
    /* \u51fd\u6570 */\n@discardableResult\nfunc function() -> Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfunc constant(n: Int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    let a = 0\n    var b = 0\n    let nums = Array(repeating: 0, count: 10000)\n    let node = ListNode(x: 0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in 0 ..< n {\n        let c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for _ in 0 ..< n {\n        function()\n    }\n}\n
    space_complexity.js
    /* \u51fd\u6570 */\nfunction constFunc() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nfunction constant(n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        const c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n
    space_complexity.ts
    /* \u51fd\u6570 */\nfunction constFunc(): number {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nfunction constant(n: number): void {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a = 0;\n    const b = 0;\n    const nums = new Array(10000);\n    const node = new ListNode(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        const c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (let i = 0; i < n; i++) {\n        constFunc();\n    }\n}\n
    space_complexity.dart
    /* \u51fd\u6570 */\nint function() {\n  // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n  return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n  // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n  final int a = 0;\n  int b = 0;\n  List<int> nums = List.filled(10000, 0);\n  ListNode node = ListNode(0);\n  // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n  for (var i = 0; i < n; i++) {\n    int c = 0;\n  }\n  // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n  for (var i = 0; i < n; i++) {\n    function();\n  }\n}\n
    space_complexity.rs
    /* \u51fd\u6570 */\nfn function() -> i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\n#[allow(unused)]\nfn constant(n: i32) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const A: i32 = 0;\n    let b = 0;\n    let nums = vec![0; 10000];\n    let node = ListNode::new(0);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for i in 0..n {\n        let c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for i in 0..n {\n        function();\n    }\n}\n
    space_complexity.c
    /* \u51fd\u6570 */\nint func() {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n/* \u5e38\u6570\u9636 */\nvoid constant(int n) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const int a = 0;\n    int b = 0;\n    int nums[1000];\n    ListNode *node = newListNode(0);\n    free(node);\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        int c = 0;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (int i = 0; i < n; i++) {\n        func();\n    }\n}\n
    space_complexity.kt
    /* \u51fd\u6570 */\nfun function(): Int {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0\n}\n\n/* \u5e38\u6570\u9636 */\nfun constant(n: Int) {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    val a = 0\n    var b = 0\n    val nums = Array(10000) { 0 }\n    val node = ListNode(0)\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    for (i in 0..<n) {\n        val c = 0\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    for (i in 0..<n) {\n        function()\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{function}\n\n[class]{}-[func]{constant}\n
    space_complexity.zig
    // \u51fd\u6570\nfn function() i32 {\n    // \u6267\u884c\u67d0\u4e9b\u64cd\u4f5c\n    return 0;\n}\n\n// \u5e38\u6570\u9636\nfn constant(n: i32) void {\n    // \u5e38\u91cf\u3001\u53d8\u91cf\u3001\u5bf9\u8c61\u5360\u7528 O(1) \u7a7a\u95f4\n    const a: i32 = 0;\n    var b: i32 = 0;\n    var nums = [_]i32{0}**10000;\n    var node = inc.ListNode(i32){.val = 0};\n    var i: i32 = 0;\n    // \u5faa\u73af\u4e2d\u7684\u53d8\u91cf\u5360\u7528 O(1) \u7a7a\u95f4\n    while (i < n) : (i += 1) {\n        var c: i32 = 0;\n        _ = c;\n    }\n    // \u5faa\u73af\u4e2d\u7684\u51fd\u6570\u5360\u7528 O(1) \u7a7a\u95f4\n    i = 0;\n    while (i < n) : (i += 1) {\n        _ = function();\n    }\n    _ = a;\n    _ = b;\n    _ = nums;\n    _ = node;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_computational_complexity/space_complexity/#2-on","title":"2. \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def linear(n: int):\n    \"\"\"\u7ebf\u6027\u9636\"\"\"\n    # \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    nums = [0] * n\n    # \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    hmap = dict[int, str]()\n    for i in range(n):\n        hmap[i] = str(i)\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\n    vector<int> nums(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    vector<ListNode> nodes;\n    for (int i = 0; i < n; i++) {\n        nodes.push_back(ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    unordered_map<int, string> map;\n    for (int i = 0; i < n; i++) {\n        map[i] = to_string(i);\n    }\n}\n
    space_complexity.java
    /* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    int[] nums = new int[n];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    List<ListNode> nodes = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        nodes.add(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    Map<Integer, String> map = new HashMap<>();\n    for (int i = 0; i < n; i++) {\n        map.put(i, String.valueOf(i));\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\n    int[] nums = new int[n];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    List<ListNode> nodes = [];\n    for (int i = 0; i < n; i++) {\n        nodes.Add(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    Dictionary<int, string> map = [];\n    for (int i = 0; i < n; i++) {\n        map.Add(i, i.ToString());\n    }\n}\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\n    var nodes []*node\n    for i := 0; i < n; i++ {\n        nodes = append(nodes, newNode(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    m := make(map[int]string, n)\n    for i := 0; i < n; i++ {\n        m[i] = strconv.Itoa(i)\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\n    let nums = Array(repeating: 0, count: n)\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let nodes = (0 ..< n).map { ListNode(x: $0) }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, \"\\($0)\") })\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\n    const nums = new Array(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const nodes = [];\n    for (let i = 0; i < n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const map = new Map();\n    for (let i = 0; i < n; i++) {\n        map.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\n    const nums = new Array(n);\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const nodes: ListNode[] = [];\n    for (let i = 0; i < n; i++) {\n        nodes.push(new ListNode(i));\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    const map = new Map();\n    for (let i = 0; i < n; i++) {\n        map.set(i, i.toString());\n    }\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\n  List<int> nums = List.filled(n, 0);\n  // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n  List<ListNode> nodes = [];\n  for (var i = 0; i < n; i++) {\n    nodes.add(ListNode(i));\n  }\n  // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n  Map<int, String> map = HashMap();\n  for (var i = 0; i < n; i++) {\n    map.putIfAbsent(i, () => i.toString());\n  }\n}\n
    space_complexity.rs
    /* \u7ebf\u6027\u9636 */\n#[allow(unused)]\nfn linear(n: i32) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut nums = vec![0; n as usize];\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut nodes = Vec::new();\n    for i in 0..n {\n        nodes.push(ListNode::new(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    let mut map = HashMap::new();\n    for i in 0..n {\n        map.insert(i, i.to_string());\n    }\n}\n
    space_complexity.c
    /* \u54c8\u5e0c\u8868 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n} HashTable;\n\n/* \u7ebf\u6027\u9636 */\nvoid linear(int n) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    int *nums = malloc(sizeof(int) * n);\n    free(nums);\n\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    ListNode **nodes = malloc(sizeof(ListNode *) * n);\n    for (int i = 0; i < n; i++) {\n        nodes[i] = newListNode(i);\n    }\n    // \u5185\u5b58\u91ca\u653e\n    for (int i = 0; i < n; i++) {\n        free(nodes[i]);\n    }\n    free(nodes);\n\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    HashTable *h = NULL;\n    for (int i = 0; i < n; i++) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp->key = i;\n        tmp->val = i;\n        HASH_ADD_INT(h, key, tmp);\n    }\n\n    // \u5185\u5b58\u91ca\u653e\n    HashTable *curr, *tmp;\n    HASH_ITER(hh, h, curr, tmp) {\n        HASH_DEL(h, curr);\n        free(curr);\n    }\n}\n
    space_complexity.kt
    /* \u7ebf\u6027\u9636 */\nfun linear(n: Int) {\n    // \u957f\u5ea6\u4e3a n \u7684\u6570\u7ec4\u5360\u7528 O(n) \u7a7a\u95f4\n    val nums = Array(n) { 0 }\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    val nodes = mutableListOf<ListNode>()\n    for (i in 0..<n) {\n        nodes.add(ListNode(i))\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    val map = mutableMapOf<Int, String>()\n    for (i in 0..<n) {\n        map[i] = i.toString()\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{linear}\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\n    var nums = [_]i32{0}**n;\n    // \u957f\u5ea6\u4e3a n \u7684\u5217\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    var nodes = std.ArrayList(i32).init(std.heap.page_allocator);\n    defer nodes.deinit();\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        try nodes.append(i);\n    }\n    // \u957f\u5ea6\u4e3a n \u7684\u54c8\u5e0c\u8868\u5360\u7528 O(n) \u7a7a\u95f4\n    var map = std.AutoArrayHashMap(i32, []const u8).init(std.heap.page_allocator);\n    defer map.deinit();\n    var j: i32 = 0;\n    while (j < n) : (j += 1) {\n        const string = try std.fmt.allocPrint(std.heap.page_allocator, \"{d}\", .{j});\n        defer std.heap.page_allocator.free(string);\n        try map.put(i, string);\n    }\n    _ = nums;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 2-17 \u6240\u793a\uff0c\u6b64\u51fd\u6570\u7684\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u5373\u540c\u65f6\u5b58\u5728 \\(n\\) \u4e2a\u672a\u8fd4\u56de\u7684 linear_recur() \u51fd\u6570\uff0c\u4f7f\u7528 \\(O(n)\\) \u5927\u5c0f\u7684\u6808\u5e27\u7a7a\u95f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def linear_recur(n: int):\n    \"\"\"\u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    print(\"\u9012\u5f52 n =\", n)\n    if n == 1:\n        return\n    linear_recur(n - 1)\n
    space_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    cout << \"\u9012\u5f52 n = \" << n << endl;\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    System.out.println(\"\u9012\u5f52 n = \" + n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid LinearRecur(int n) {\n    Console.WriteLine(\"\u9012\u5f52 n = \" + n);\n    if (n == 1) return;\n    LinearRecur(n - 1);\n}\n
    space_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceLinearRecur(n int) {\n    fmt.Println(\"\u9012\u5f52 n =\", n)\n    if n == 1 {\n        return\n    }\n    spaceLinearRecur(n - 1)\n}\n
    space_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc linearRecur(n: Int) {\n    print(\"\u9012\u5f52 n = \\(n)\")\n    if n == 1 {\n        return\n    }\n    linearRecur(n: n - 1)\n}\n
    space_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n) {\n    console.log(`\u9012\u5f52 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction linearRecur(n: number): void {\n    console.log(`\u9012\u5f52 n = ${n}`);\n    if (n === 1) return;\n    linearRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n  print('\u9012\u5f52 n = $n');\n  if (n == 1) return;\n  linearRecur(n - 1);\n}\n
    space_complexity.rs
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn linear_recur(n: i32) {\n    println!(\"\u9012\u5f52 n = {}\", n);\n    if n == 1 {\n        return;\n    };\n    linear_recur(n - 1);\n}\n
    space_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nvoid linearRecur(int n) {\n    printf(\"\u9012\u5f52 n = %d\\r\\n\", n);\n    if (n == 1)\n        return;\n    linearRecur(n - 1);\n}\n
    space_complexity.kt
    /* \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun linearRecur(n: Int) {\n    println(\"\u9012\u5f52 n = $n\")\n    if (n == 1)\n        return\n    linearRecur(n - 1)\n}\n
    space_complexity.rb
    [class]{}-[func]{linear_recur}\n
    space_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn linearRecur(comptime n: i32) void {\n    std.debug.print(\"\u9012\u5f52 n = {}\\n\", .{n});\n    if (n == 1) return;\n    linearRecur(n - 1);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-17 \u00a0 \u9012\u5f52\u51fd\u6570\u4ea7\u751f\u7684\u7ebf\u6027\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

    "},{"location":"chapter_computational_complexity/space_complexity/#3-on2","title":"3. \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def quadratic(n: int):\n    \"\"\"\u5e73\u65b9\u9636\"\"\"\n    # \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    num_matrix = [[0] * n for _ in range(n)]\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    vector<vector<int>> numMatrix;\n    for (int i = 0; i < n; i++) {\n        vector<int> tmp;\n        for (int j = 0; j < n; j++) {\n            tmp.push_back(0);\n        }\n        numMatrix.push_back(tmp);\n    }\n}\n
    space_complexity.java
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    int[][] numMatrix = new int[n][n];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    List<List<Integer>> numList = new ArrayList<>();\n    for (int i = 0; i < n; i++) {\n        List<Integer> tmp = new ArrayList<>();\n        for (int j = 0; j < n; j++) {\n            tmp.add(0);\n        }\n        numList.add(tmp);\n    }\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636 */\nvoid Quadratic(int n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    int[,] numMatrix = new int[n, n];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    List<List<int>> numList = [];\n    for (int i = 0; i < n; i++) {\n        List<int> tmp = [];\n        for (int j = 0; j < n; j++) {\n            tmp.Add(0);\n        }\n        numList.Add(tmp);\n    }\n}\n
    space_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc spaceQuadratic(n int) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    numMatrix := make([][]int, n)\n    for i := 0; i < n; i++ {\n        numMatrix[i] = make([]int, n)\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\n    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() => Array(n).fill(null));\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numList = [];\n    for (let i = 0; i < n; i++) {\n        const tmp = [];\n        for (let j = 0; j < n; j++) {\n            tmp.push(0);\n        }\n        numList.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\n    const numMatrix = Array(n)\n        .fill(null)\n        .map(() => Array(n).fill(null));\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    const numList = [];\n    for (let i = 0; i < n; i++) {\n        const tmp = [];\n        for (let j = 0; j < n; j++) {\n            tmp.push(0);\n        }\n        numList.push(tmp);\n    }\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636 */\nvoid quadratic(int n) {\n  // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n  List<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));\n  // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n  List<List<int>> numList = [];\n  for (var i = 0; i < n; i++) {\n    List<int> tmp = [];\n    for (int j = 0; j < n; j++) {\n      tmp.add(0);\n    }\n    numList.add(tmp);\n  }\n}\n
    space_complexity.rs
    /* \u5e73\u65b9\u9636 */\n#[allow(unused)]\nfn quadratic(n: i32) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    let num_matrix = vec![vec![0; n as usize]; n as usize];\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    let mut num_list = Vec::new();\n    for i in 0..n {\n        let mut tmp = Vec::new();\n        for j in 0..n {\n            tmp.push(0);\n        }\n        num_list.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\n    int **numMatrix = malloc(sizeof(int *) * n);\n    for (int i = 0; i < n; i++) {\n        int *tmp = malloc(sizeof(int) * n);\n        for (int j = 0; j < n; j++) {\n            tmp[j] = 0;\n        }\n        numMatrix[i] = tmp;\n    }\n\n    // \u5185\u5b58\u91ca\u653e\n    for (int i = 0; i < n; i++) {\n        free(numMatrix[i]);\n    }\n    free(numMatrix);\n}\n
    space_complexity.kt
    /* \u5e73\u65b9\u9636 */\nfun quadratic(n: Int) {\n    // \u77e9\u9635\u5360\u7528 O(n^2) \u7a7a\u95f4\n    val numMatrix: Array<Array<Int>?> = arrayOfNulls(n)\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    val numList: MutableList<MutableList<Int>> = arrayListOf()\n    for (i in 0..<n) {\n        val tmp = mutableListOf<Int>()\n        for (j in 0..<n) {\n            tmp.add(0)\n        }\n        numList.add(tmp)\n    }\n}\n
    space_complexity.rb
    [class]{}-[func]{quadratic}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) !void {\n    // \u4e8c\u7ef4\u5217\u8868\u5360\u7528 O(n^2) \u7a7a\u95f4\n    var nodes = std.ArrayList(std.ArrayList(i32)).init(std.heap.page_allocator);\n    defer nodes.deinit();\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        var tmp = std.ArrayList(i32).init(std.heap.page_allocator);\n        defer tmp.deinit();\n        var j: i32 = 0;\n        while (j < n) : (j += 1) {\n            try tmp.append(0);\n        }\n        try nodes.append(tmp);\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 2-18 \u6240\u793a\uff0c\u8be5\u51fd\u6570\u7684\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \uff0c\u5728\u6bcf\u4e2a\u9012\u5f52\u51fd\u6570\u4e2d\u90fd\u521d\u59cb\u5316\u4e86\u4e00\u4e2a\u6570\u7ec4\uff0c\u957f\u5ea6\u5206\u522b\u4e3a \\(n\\)\u3001\\(n-1\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \uff0c\u5e73\u5747\u957f\u5ea6\u4e3a \\(n / 2\\) \uff0c\u56e0\u6b64\u603b\u4f53\u5360\u7528 \\(O(n^2)\\) \u7a7a\u95f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def quadratic_recur(n: int) -> int:\n    \"\"\"\u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n <= 0:\n        return 0\n    # \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    nums = [0] * n\n    return quadratic_recur(n - 1)\n
    space_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    vector<int> nums(n);\n    cout << \"\u9012\u5f52 n = \" << n << \" \u4e2d\u7684 nums \u957f\u5ea6 = \" << nums.size() << endl;\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    int[] nums = new int[n];\n    System.out.println(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.length);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint QuadraticRecur(int n) {\n    if (n <= 0) return 0;\n    int[] nums = new int[n];\n    Console.WriteLine(\"\u9012\u5f52 n = \" + n + \" \u4e2d\u7684 nums \u957f\u5ea6 = \" + nums.Length);\n    return QuadraticRecur(n - 1);\n}\n
    space_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc spaceQuadraticRecur(n int) int {\n    if n <= 0 {\n        return 0\n    }\n    nums := make([]int, n)\n    fmt.Printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d \\n\", n, len(nums))\n    return spaceQuadraticRecur(n - 1)\n}\n
    space_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\n@discardableResult\nfunc quadraticRecur(n: Int) -> Int {\n    if n <= 0 {\n        return 0\n    }\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    let nums = Array(repeating: 0, count: n)\n    print(\"\u9012\u5f52 n = \\(n) \u4e2d\u7684 nums \u957f\u5ea6 = \\(nums.count)\")\n    return quadraticRecur(n: n - 1)\n}\n
    space_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n) {\n    if (n <= 0) return 0;\n    const nums = new Array(n);\n    console.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction quadraticRecur(n: number): number {\n    if (n <= 0) return 0;\n    const nums = new Array(n);\n    console.log(`\u9012\u5f52 n = ${n} \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}`);\n    return quadraticRecur(n - 1);\n}\n
    space_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n  if (n <= 0) return 0;\n  List<int> nums = List.filled(n, 0);\n  print('\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.length}');\n  return quadraticRecur(n - 1);\n}\n
    space_complexity.rs
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn quadratic_recur(n: i32) -> i32 {\n    if n <= 0 {\n        return 0;\n    };\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    let nums = vec![0; n as usize];\n    println!(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\", n, nums.len());\n    return quadratic_recur(n - 1);\n}\n
    space_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint quadraticRecur(int n) {\n    if (n <= 0)\n        return 0;\n    int *nums = malloc(sizeof(int) * n);\n    printf(\"\u9012\u5f52 n = %d \u4e2d\u7684 nums \u957f\u5ea6 = %d\\r\\n\", n, n);\n    int res = quadraticRecur(n - 1);\n    free(nums);\n    return res;\n}\n
    space_complexity.kt
    /* \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\ntailrec fun quadraticRecur(n: Int): Int {\n    if (n <= 0)\n        return 0\n    // \u6570\u7ec4 nums \u957f\u5ea6\u4e3a n, n-1, ..., 2, 1\n    val nums = Array(n) { 0 }\n    println(\"\u9012\u5f52 n = $n \u4e2d\u7684 nums \u957f\u5ea6 = ${nums.size}\")\n    return quadraticRecur(n - 1)\n}\n
    space_complexity.rb
    [class]{}-[func]{quadratic_recur}\n
    space_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn quadraticRecur(comptime n: i32) i32 {\n    if (n <= 0) return 0;\n    var nums = [_]i32{0}**n;\n    std.debug.print(\"\u9012\u5f52 n = {} \u4e2d\u7684 nums \u957f\u5ea6 = {}\\n\", .{n, nums.len});\n    return quadraticRecur(n - 1);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-18 \u00a0 \u9012\u5f52\u51fd\u6570\u4ea7\u751f\u7684\u5e73\u65b9\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

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

    \u6307\u6570\u9636\u5e38\u89c1\u4e8e\u4e8c\u53c9\u6811\u3002\u89c2\u5bdf\u56fe 2-19 \uff0c\u5c42\u6570\u4e3a \\(n\\) \u7684\u201c\u6ee1\u4e8c\u53c9\u6811\u201d\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(2^n - 1\\) \uff0c\u5360\u7528 \\(O(2^n)\\) \u7a7a\u95f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig space_complexity.py
    def build_tree(n: int) -> TreeNode | None:\n    \"\"\"\u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09\"\"\"\n    if n == 0:\n        return None\n    root = TreeNode(0)\n    root.left = build_tree(n - 1)\n    root.right = build_tree(n - 1)\n    return root\n
    space_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return nullptr;\n    TreeNode *root = new TreeNode(0);\n    root->left = buildTree(n - 1);\n    root->right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.java
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode buildTree(int n) {\n    if (n == 0)\n        return null;\n    TreeNode root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? BuildTree(int n) {\n    if (n == 0) return null;\n    TreeNode root = new(0) {\n        left = BuildTree(n - 1),\n        right = BuildTree(n - 1)\n    };\n    return root;\n}\n
    space_complexity.go
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n int) *TreeNode {\n    if n == 0 {\n        return nil\n    }\n    root := NewTreeNode(0)\n    root.Left = buildTree(n - 1)\n    root.Right = buildTree(n - 1)\n    return root\n}\n
    space_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunc buildTree(n: Int) -> TreeNode? {\n    if n == 0 {\n        return nil\n    }\n    let root = TreeNode(x: 0)\n    root.left = buildTree(n: n - 1)\n    root.right = buildTree(n: n - 1)\n    return root\n}\n
    space_complexity.js
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n) {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfunction buildTree(n: number): TreeNode | null {\n    if (n === 0) return null;\n    const root = new TreeNode(0);\n    root.left = buildTree(n - 1);\n    root.right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode? buildTree(int n) {\n  if (n == 0) return null;\n  TreeNode root = TreeNode(0);\n  root.left = buildTree(n - 1);\n  root.right = buildTree(n - 1);\n  return root;\n}\n
    space_complexity.rs
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfn build_tree(n: i32) -> Option<Rc<RefCell<TreeNode>>> {\n    if n == 0 {\n        return None;\n    };\n    let root = TreeNode::new(0);\n    root.borrow_mut().left = build_tree(n - 1);\n    root.borrow_mut().right = build_tree(n - 1);\n    return Some(root);\n}\n
    space_complexity.c
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nTreeNode *buildTree(int n) {\n    if (n == 0)\n        return NULL;\n    TreeNode *root = newTreeNode(0);\n    root->left = buildTree(n - 1);\n    root->right = buildTree(n - 1);\n    return root;\n}\n
    space_complexity.kt
    /* \u6307\u6570\u9636\uff08\u5efa\u7acb\u6ee1\u4e8c\u53c9\u6811\uff09 */\nfun buildTree(n: Int): TreeNode? {\n    if (n == 0)\n        return null\n    val root = TreeNode(0)\n    root.left = buildTree(n - 1)\n    root.right = buildTree(n - 1)\n    return root\n}\n
    space_complexity.rb
    [class]{}-[func]{build_tree}\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) {\n    if (n == 0) return null;\n    const root = try mem_allocator.create(inc.TreeNode(i32));\n    root.init(0);\n    root.left = try buildTree(mem_allocator, n - 1);\n    root.right = try buildTree(mem_allocator, n - 1);\n    return root;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-19 \u00a0 \u6ee1\u4e8c\u53c9\u6811\u4ea7\u751f\u7684\u6307\u6570\u9636\u7a7a\u95f4\u590d\u6742\u5ea6

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

    \u5bf9\u6570\u9636\u5e38\u89c1\u4e8e\u5206\u6cbb\u7b97\u6cd5\u3002\u4f8b\u5982\u5f52\u5e76\u6392\u5e8f\uff0c\u8f93\u5165\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\uff0c\u6bcf\u8f6e\u9012\u5f52\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5904\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\u5c06\u6570\u5b57\u8f6c\u5316\u4e3a\u5b57\u7b26\u4e32\uff0c\u8f93\u5165\u4e00\u4e2a\u6b63\u6574\u6570 \\(n\\) \uff0c\u5b83\u7684\u4f4d\u6570\u4e3a \\(\\lfloor \\log_{10} n \\rfloor + 1\\) \uff0c\u5373\u5bf9\u5e94\u5b57\u7b26\u4e32\u957f\u5ea6\u4e3a \\(\\lfloor \\log_{10} n \\rfloor + 1\\) \uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log_{10} n + 1) = O(\\log n)\\) \u3002

    "},{"location":"chapter_computational_complexity/space_complexity/#244","title":"2.4.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\u975e\u5e38\u56f0\u96be\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\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\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\u975e\u5e38\u91cd\u8981\u3002

    "},{"location":"chapter_computational_complexity/summary/","title":"2.5 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_computational_complexity/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","text":"

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

    • \u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u662f\u8861\u91cf\u7b97\u6cd5\u4f18\u52a3\u7684\u4e24\u4e2a\u4e3b\u8981\u8bc4\u4ef7\u6307\u6807\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\u6d88\u9664\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\u7684\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\u5bf9\u5e94\u51fd\u6570\u6e10\u8fd1\u4e0a\u754c\uff0c\u53cd\u6620\u5f53 \\(n\\) \u8d8b\u5411\u6b63\u65e0\u7a77\u65f6\uff0c\u64cd\u4f5c\u6570\u91cf \\(T(n)\\) \u7684\u589e\u957f\u7ea7\u522b\u3002
    • \u63a8\u7b97\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u4e3a\u4e24\u6b65\uff0c\u9996\u5148\u7edf\u8ba1\u64cd\u4f5c\u6570\u91cf\uff0c\u7136\u540e\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c\u3002
    • \u5e38\u89c1\u65f6\u95f4\u590d\u6742\u5ea6\u4ece\u4f4e\u5230\u9ad8\u6392\u5217\u6709 \\(O(1)\\)\u3001\\(O(\\log n)\\)\u3001\\(O(n)\\)\u3001\\(O(n \\log n)\\)\u3001\\(O(n^2)\\)\u3001\\(O(2^n)\\) \u548c \\(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

    • \u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u4f5c\u7528\u7c7b\u4f3c\u4e8e\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u7528\u4e8e\u8861\u91cf\u7b97\u6cd5\u5360\u7528\u5185\u5b58\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\u7eb3\u5165\u7a7a\u95f4\u590d\u6742\u5ea6\u8ba1\u7b97\u3002\u6682\u5b58\u7a7a\u95f4\u53ef\u5206\u4e3a\u6682\u5b58\u6570\u636e\u3001\u6808\u5e27\u7a7a\u95f4\u548c\u6307\u4ee4\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\u523b\u4e0b\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u3002
    • \u5e38\u89c1\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece\u4f4e\u5230\u9ad8\u6392\u5217\u6709 \\(O(1)\\)\u3001\\(O(\\log n)\\)\u3001\\(O(n)\\)\u3001\\(O(n^2)\\) \u548c \\(O(2^n)\\) \u7b49\u3002
    "},{"location":"chapter_computational_complexity/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u4f18\u5316\u81f3 \\(O(1)\\) \u3002\u4e0d\u8fc7\u7edd\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\uff08\u4f8b\u5982 Java\u3001Python\u3001C++\u3001Go\u3001C# \u7b49\uff09\u4e0d\u652f\u6301\u81ea\u52a8\u4f18\u5316\u5c3e\u9012\u5f52\uff0c\u56e0\u6b64\u901a\u5e38\u8ba4\u4e3a\u7a7a\u95f4\u590d\u6742\u5ea6\u662f \\(O(n)\\) \u3002

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

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

    \u4e0b\u9762\u4ee5\u51e0\u79cd\u5e38\u89c1\u7684\u7f16\u7a0b\u8bed\u8a00\u4e3a\u4f8b\u6765\u8bf4\u660e\u3002

    • C \u8bed\u8a00\u662f\u8fc7\u7a0b\u5f0f\u7f16\u7a0b\u8bed\u8a00\uff0c\u6ca1\u6709\u9762\u5411\u5bf9\u8c61\u7684\u6982\u5ff5\uff0c\u6240\u4ee5\u53ea\u6709\u51fd\u6570\u3002\u4f46\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u521b\u5efa\u7ed3\u6784\u4f53\uff08struct\uff09\u6765\u6a21\u62df\u9762\u5411\u5bf9\u8c61\u7f16\u7a0b\uff0c\u4e0e\u7ed3\u6784\u4f53\u76f8\u5173\u8054\u7684\u51fd\u6570\u5c31\u76f8\u5f53\u4e8e\u5176\u4ed6\u7f16\u7a0b\u8bed\u8a00\u4e2d\u7684\u65b9\u6cd5\u3002
    • Java \u548c C# \u662f\u9762\u5411\u5bf9\u8c61\u7684\u7f16\u7a0b\u8bed\u8a00\uff0c\u4ee3\u7801\u5757\uff08\u65b9\u6cd5\uff09\u901a\u5e38\u4f5c\u4e3a\u67d0\u4e2a\u7c7b\u7684\u4e00\u90e8\u5206\u3002\u9759\u6001\u65b9\u6cd5\u7684\u884c\u4e3a\u7c7b\u4f3c\u4e8e\u51fd\u6570\uff0c\u56e0\u4e3a\u5b83\u88ab\u7ed1\u5b9a\u5728\u7c7b\u4e0a\uff0c\u4e0d\u80fd\u8bbf\u95ee\u7279\u5b9a\u7684\u5b9e\u4f8b\u53d8\u91cf\u3002
    • C++ \u548c Python \u65e2\u652f\u6301\u8fc7\u7a0b\u5f0f\u7f16\u7a0b\uff08\u51fd\u6570\uff09\uff0c\u4e5f\u652f\u6301\u9762\u5411\u5bf9\u8c61\u7f16\u7a0b\uff08\u65b9\u6cd5\uff09\u3002

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

    \u4e0d\u662f\uff0c\u8be5\u56fe\u5c55\u793a\u7684\u662f\u7a7a\u95f4\u590d\u6742\u5ea6\uff0c\u5176\u53cd\u6620\u7684\u662f\u589e\u957f\u8d8b\u52bf\uff0c\u800c\u4e0d\u662f\u5360\u7528\u7a7a\u95f4\u7684\u7edd\u5bf9\u5927\u5c0f\u3002

    \u5047\u8bbe\u53d6 \\(n = 8\\) \uff0c\u4f60\u53ef\u80fd\u4f1a\u53d1\u73b0\u6bcf\u6761\u66f2\u7ebf\u7684\u503c\u4e0e\u51fd\u6570\u5bf9\u5e94\u4e0d\u4e0a\u3002\u8fd9\u662f\u56e0\u4e3a\u6bcf\u6761\u66f2\u7ebf\u90fd\u5305\u542b\u4e00\u4e2a\u5e38\u6570\u9879\uff0c\u7528\u4e8e\u5c06\u53d6\u503c\u8303\u56f4\u538b\u7f29\u5230\u4e00\u4e2a\u89c6\u89c9\u8212\u9002\u7684\u8303\u56f4\u5185\u3002

    \u5728\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\u3002\u4f46\u5bf9\u4e8e \\(n = 8^5\\) \u5c31\u5f88\u597d\u9009\u4e86\uff0c\u8fd9\u65f6\u589e\u957f\u8d8b\u52bf\u5df2\u7ecf\u5360\u4e3b\u5bfc\u4e86\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/","title":"2.3 \u00a0 \u65f6\u95f4\u590d\u6742\u5ea6","text":"

    \u8fd0\u884c\u65f6\u95f4\u53ef\u4ee5\u76f4\u89c2\u4e14\u51c6\u786e\u5730\u53cd\u6620\u7b97\u6cd5\u7684\u6548\u7387\u3002\u5982\u679c\u6211\u4eec\u60f3\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 print() \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\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u8f93\u5165\u6570\u636e\u5927\u5c0f\u4e3a \\(n\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\ndef algorithm(n: int):\n    a = 2      # 1 ns\n    a = a + 1  # 1 ns\n    a = a * 2  # 10 ns\n    # \u5faa\u73af n \u6b21\n    for _ in range(n):  # 1 ns\n        print(0)        # 5 ns\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        cout << 0 << endl;         // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        System.out.println(0);     // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid Algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        Console.WriteLine(0);      // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunc algorithm(n int) {\n    a := 2     // 1 ns\n    a = a + 1  // 1 ns\n    a = a * 2  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for i := 0; i < n; i++ {  // 1 ns\n        fmt.Println(a)        // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunc algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // \u5faa\u73af n \u6b21\n    for _ in 0 ..< n { // 1 ns\n        print(0) // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunction algorithm(n) {\n    var a = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // \u5faa\u73af n \u6b21\n    for(let i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        console.log(0); // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfunction algorithm(n: number): void {\n    var a: number = 2; // 1 ns\n    a = a + 1; // 1 ns\n    a = a * 2; // 10 ns\n    // \u5faa\u73af n \u6b21\n    for(let i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        console.log(0); // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\n  int a = 2; // 1 ns\n  a = a + 1; // 1 ns\n  a = a * 2; // 10 ns\n  // \u5faa\u73af n \u6b21\n  for (int i = 0; i < n; i++) { // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n    print(0); // 5 ns\n  }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfn algorithm(n: i32) {\n    let mut a = 2;      // 1 ns\n    a = a + 1;          // 1 ns\n    a = a * 2;          // 10 ns\n    // \u5faa\u73af n \u6b21\n    for _ in 0..n {     // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        println!(\"{}\", 0);  // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nvoid algorithm(int n) {\n    int a = 2;  // 1 ns\n    a = a + 1;  // 1 ns\n    a = a * 2;  // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {   // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        printf(\"%d\", 0);            // 5 ns\n    }\n}\n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfun algorithm(n: Int) {\n    var a = 2 // 1 ns\n    a = a + 1 // 1 ns\n    a = a * 2 // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (i in 0..<n) {  // 1 ns \uff0c\u6bcf\u8f6e\u90fd\u8981\u6267\u884c i++\n        println(0)      // 5 ns\n    }\n}\n
    \n
    // \u5728\u67d0\u8fd0\u884c\u5e73\u53f0\u4e0b\nfn algorithm(n: usize) void {\n    var a: i32 = 2; // 1 ns\n    a += 1; // 1 ns\n    a *= 2; // 10 ns\n    // \u5faa\u73af n \u6b21\n    for (0..n) |_| { // 1 ns\n        std.debug.print(\"{}\\n\", .{0}); // 5 ns\n    }\n}\n

    \u6839\u636e\u4ee5\u4e0a\u65b9\u6cd5\uff0c\u53ef\u4ee5\u5f97\u5230\u7b97\u6cd5\u7684\u8fd0\u884c\u65f6\u95f4\u4e3a \\((6n + 12)\\) ns \uff1a

    \\[ 1 + 1 + 10 + (1 + 5) \\times n = 6n + 12 \\]

    \u4f46\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\u5c06\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/#231","title":"2.3.1 \u00a0 \u7edf\u8ba1\u65f6\u95f4\u589e\u957f\u8d8b\u52bf","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\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\u6bd4\u8f83\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\u3001B \u548c C \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\ndef algorithm_A(n: int):\n    print(0)\n# \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\ndef algorithm_B(n: int):\n    for _ in range(n):\n        print(0)\n# \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\ndef algorithm_C(n: int):\n    for _ in range(1000000):\n        print(0)\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\n    cout << 0 << endl;\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        cout << 0 << endl;\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        cout << 0 << endl;\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\n    System.out.println(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        System.out.println(0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        System.out.println(0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid AlgorithmA(int n) {\n    Console.WriteLine(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid AlgorithmB(int n) {\n    for (int i = 0; i < n; i++) {\n        Console.WriteLine(0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid AlgorithmC(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        Console.WriteLine(0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithm_A(n int) {\n    fmt.Println(0)\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunc algorithm_B(n int) {\n    for i := 0; i < n; i++ {\n        fmt.Println(0)\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithm_C(n int) {\n    for i := 0; i < 1000000; i++ {\n        fmt.Println(0)\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithmA(n: Int) {\n    print(0)\n}\n\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunc algorithmB(n: Int) {\n    for _ in 0 ..< n {\n        print(0)\n    }\n}\n\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunc algorithmC(n: Int) {\n    for _ in 0 ..< 1_000_000 {\n        print(0)\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_A(n) {\n    console.log(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunction algorithm_B(n) {\n    for (let i = 0; i < n; i++) {\n        console.log(0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_C(n) {\n    for (let i = 0; i < 1000000; i++) {\n        console.log(0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_A(n: number): void {\n    console.log(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfunction algorithm_B(n: number): void {\n    for (let i = 0; i < n; i++) {\n        console.log(0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfunction algorithm_C(n: number): void {\n    for (let i = 0; i < 1000000; i++) {\n        console.log(0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithmA(int n) {\n  print(0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithmB(int n) {\n  for (int i = 0; i < n; i++) {\n    print(0);\n  }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithmC(int n) {\n  for (int i = 0; i < 1000000; i++) {\n    print(0);\n  }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfn algorithm_A(n: i32) {\n    println!(\"{}\", 0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfn algorithm_B(n: i32) {\n    for _ in 0..n {\n        println!(\"{}\", 0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfn algorithm_C(n: i32) {\n    for _ in 0..1000000 {\n        println!(\"{}\", 0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_A(int n) {\n    printf(\"%d\", 0);\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nvoid algorithm_B(int n) {\n    for (int i = 0; i < n; i++) {\n        printf(\"%d\", 0);\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nvoid algorithm_C(int n) {\n    for (int i = 0; i < 1000000; i++) {\n        printf(\"%d\", 0);\n    }\n}\n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfun algoritm_A(n: Int) {\n    println(0)\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfun algorithm_B(n: Int) {\n    for (i in 0..<n){\n        println(0)\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfun algorithm_C(n: Int) {\n    for (i in 0..<1000000) {\n        println(0)\n    }\n}\n
    \n
    // \u7b97\u6cd5 A \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfn algorithm_A(n: usize) void {\n    _ = n;\n    std.debug.print(\"{}\\n\", .{0});\n}\n// \u7b97\u6cd5 B \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u7ebf\u6027\u9636\nfn algorithm_B(n: i32) void {\n    for (0..n) |_| {\n        std.debug.print(\"{}\\n\", .{0});\n    }\n}\n// \u7b97\u6cd5 C \u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a\u5e38\u6570\u9636\nfn algorithm_C(n: i32) void {\n    _ = n;\n    for (0..1000000) |_| { \n        std.debug.print(\"{}\\n\", .{0});\n    }\n}\n

    \u56fe 2-7 \u5c55\u793a\u4e86\u4ee5\u4e0a\u4e09\u4e2a\u7b97\u6cd5\u51fd\u6570\u7684\u65f6\u95f4\u590d\u6742\u5ea6\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\u201c\u5e38\u6570\u9636\u201d\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\u201c\u7ebf\u6027\u9636\u201d\u3002
    • \u7b97\u6cd5 C \u4e2d\u7684\u6253\u5370\u64cd\u4f5c\u9700\u8981\u5faa\u73af \\(1000000\\) \u6b21\uff0c\u867d\u7136\u8fd0\u884c\u65f6\u95f4\u5f88\u957f\uff0c\u4f46\u5b83\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\u201c\u5e38\u6570\u9636\u201d\u3002

    \u56fe 2-7 \u00a0 \u7b97\u6cd5 A\u3001B \u548c C \u7684\u65f6\u95f4\u589e\u957f\u8d8b\u52bf

    \u76f8\u8f83\u4e8e\u76f4\u63a5\u7edf\u8ba1\u7b97\u6cd5\u7684\u8fd0\u884c\u65f6\u95f4\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u6709\u54ea\u4e9b\u7279\u70b9\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 \u66f4\u6162\uff0c\u5728 \\(n > 1000000\\) \u65f6\u6bd4\u7b97\u6cd5 C \u66f4\u6162\u3002\u4e8b\u5b9e\u4e0a\uff0c\u53ea\u8981\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u8db3\u591f\u5927\uff0c\u590d\u6742\u5ea6\u4e3a\u201c\u5e38\u6570\u9636\u201d\u7684\u7b97\u6cd5\u4e00\u5b9a\u4f18\u4e8e\u201c\u7ebf\u6027\u9636\u201d\u7684\u7b97\u6cd5\uff0c\u8fd9\u6b63\u662f\u65f6\u95f4\u589e\u957f\u8d8b\u52bf\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\u8fd0\u884c\u65f6\u95f4\u7edf\u8ba1\u201d\u7b80\u5316\u4e3a\u201c\u8ba1\u7b97\u64cd\u4f5c\u6570\u91cf\u7edf\u8ba1\u201d\uff0c\u8fd9\u6837\u4e00\u6765\u4f30\u7b97\u96be\u5ea6\u5c31\u5927\u5927\u964d\u4f4e\u4e86\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\u7684\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/#232","title":"2.3.2 \u00a0 \u51fd\u6570\u6e10\u8fd1\u4e0a\u754c","text":"

    \u7ed9\u5b9a\u4e00\u4e2a\u8f93\u5165\u5927\u5c0f\u4e3a \\(n\\) \u7684\u51fd\u6570\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def algorithm(n: int):\n    a = 1      # +1\n    a = a + 1  # +1\n    a = a * 2  # +1\n    # \u5faa\u73af n \u6b21\n    for i in range(n):  # +1\n        print(0)        # +1\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        cout << 0 << endl;    // +1\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        System.out.println(0);    // +1\n    }\n}\n
    void Algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {   // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        Console.WriteLine(0);   // +1\n    }\n}\n
    func algorithm(n int) {\n    a := 1      // +1\n    a = a + 1   // +1\n    a = a * 2   // +1\n    // \u5faa\u73af n \u6b21\n    for i := 0; i < n; i++ {   // +1\n        fmt.Println(a)         // +1\n    }\n}\n
    func algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // \u5faa\u73af n \u6b21\n    for _ in 0 ..< n { // +1\n        print(0) // +1\n    }\n}\n
    function algorithm(n) {\n    var a = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // \u5faa\u73af n \u6b21\n    for(let i = 0; i < n; i++){ // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        console.log(0); // +1\n    }\n}\n
    function algorithm(n: number): void{\n    var a: number = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // \u5faa\u73af n \u6b21\n    for(let i = 0; i < n; i++){ // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        console.log(0); // +1\n    }\n}\n
    void algorithm(int n) {\n  int a = 1; // +1\n  a = a + 1; // +1\n  a = a * 2; // +1\n  // \u5faa\u73af n \u6b21\n  for (int i = 0; i < n; i++) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n    print(0); // +1\n  }\n}\n
    fn algorithm(n: i32) {\n    let mut a = 1;   // +1\n    a = a + 1;      // +1\n    a = a * 2;      // +1\n\n    // \u5faa\u73af n \u6b21\n    for _ in 0..n { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        println!(\"{}\", 0); // +1\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +1\n    a = a + 1;  // +1\n    a = a * 2;  // +1\n    // \u5faa\u73af n \u6b21\n    for (int i = 0; i < n; i++) {   // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        printf(\"%d\", 0);            // +1\n    }\n}  \n
    fun algorithm(n: Int) {\n    var a = 1 // +1\n    a = a + 1 // +1\n    a = a * 2 // +1\n    // \u5faa\u73af n \u6b21\n    for (i in 0..<n) { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        println(0) // +1\n    }\n}\n
    \n
    fn algorithm(n: usize) void {\n    var a: i32 = 1; // +1\n    a += 1; // +1\n    a *= 2; // +1\n    // \u5faa\u73af n \u6b21\n    for (0..n) |_| { // +1\uff08\u6bcf\u8f6e\u90fd\u6267\u884c i ++\uff09\n        std.debug.print(\"{}\\n\", .{0}); // +1\n    }\n}\n

    \u8bbe\u7b97\u6cd5\u7684\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\u4e0a\u51fd\u6570\u7684\u64cd\u4f5c\u6570\u91cf\u4e3a\uff1a

    \\[ T(n) = 3 + 2n \\]

    \\(T(n)\\) \u662f\u4e00\u6b21\u51fd\u6570\uff0c\u8bf4\u660e\u5176\u8fd0\u884c\u65f6\u95f4\u7684\u589e\u957f\u8d8b\u52bf\u662f\u7ebf\u6027\u7684\uff0c\u56e0\u6b64\u5b83\u7684\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

    \u65f6\u95f4\u590d\u6742\u5ea6\u5206\u6790\u672c\u8d28\u4e0a\u662f\u8ba1\u7b97\u201c\u64cd\u4f5c\u6570\u91cf \\(T(n)\\)\u201d\u7684\u6e10\u8fd1\u4e0a\u754c\uff0c\u5b83\u5177\u6709\u660e\u786e\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)\\) \uff0c\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))\\) \u3002

    \u5982\u56fe 2-8 \u6240\u793a\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

    \u56fe 2-8 \u00a0 \u51fd\u6570\u7684\u6e10\u8fd1\u4e0a\u754c

    "},{"location":"chapter_computational_complexity/time_complexity/#233","title":"2.3.3 \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\u987b\u62c5\u5fc3\u3002\u6211\u4eec\u53ef\u4ee5\u5148\u638c\u63e1\u63a8\u7b97\u65b9\u6cd5\uff0c\u5728\u4e0d\u65ad\u7684\u5b9e\u8df5\u4e2d\uff0c\u5c31\u53ef\u4ee5\u9010\u6e10\u9886\u609f\u5176\u6570\u5b66\u610f\u4e49\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":"1. \u00a0 \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\u5ffd\u7565\u3002\u6839\u636e\u6b64\u539f\u5219\uff0c\u53ef\u4ee5\u603b\u7ed3\u51fa\u4ee5\u4e0b\u8ba1\u6570\u7b80\u5316\u6280\u5de7\u3002

    1. \u5ffd\u7565 \\(T(n)\\) \u4e2d\u7684\u5e38\u6570\u9879\u3002\u56e0\u4e3a\u5b83\u4eec\u90fd\u4e0e \\(n\\) \u65e0\u5173\uff0c\u6240\u4ee5\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\u7b2c 1. \u70b9\u548c\u7b2c 2. \u70b9\u7684\u6280\u5de7\u3002

    \u7ed9\u5b9a\u4e00\u4e2a\u51fd\u6570\uff0c\u6211\u4eec\u53ef\u4ee5\u7528\u4e0a\u8ff0\u6280\u5de7\u6765\u7edf\u8ba1\u64cd\u4f5c\u6570\u91cf\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    def algorithm(n: int):\n    a = 1      # +0\uff08\u6280\u5de7 1\uff09\n    a = a + n  # +0\uff08\u6280\u5de7 1\uff09\n    # +n\uff08\u6280\u5de7 2\uff09\n    for i in range(5 * n + 1):\n        print(0)\n    # +n*n\uff08\u6280\u5de7 3\uff09\n    for i in range(2 * n):\n        for j in range(n + 1):\n            print(0)\n
    void algorithm(int n) {\n    int a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (int i = 0; i < 5 * n + 1; i++) {\n        cout << 0 << endl;\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            cout << 0 << endl;\n        }\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (int i = 0; i < 5 * n + 1; i++) {\n        System.out.println(0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            System.out.println(0);\n        }\n    }\n}\n
    void Algorithm(int n) {\n    int a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (int i = 0; i < 5 * n + 1; i++) {\n        Console.WriteLine(0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            Console.WriteLine(0);\n        }\n    }\n}\n
    func algorithm(n int) {\n    a := 1     // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for i := 0; i < 5 * n + 1; i++ {\n        fmt.Println(0)\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for i := 0; i < 2 * n; i++ {\n        for j := 0; j < n + 1; j++ {\n            fmt.Println(0)\n        }\n    }\n}\n
    func algorithm(n: Int) {\n    var a = 1 // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for _ in 0 ..< (5 * n + 1) {\n        print(0)\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for _ in 0 ..< (2 * n) {\n        for _ in 0 ..< (n + 1) {\n            print(0)\n        }\n    }\n}\n
    function algorithm(n) {\n    let a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (let i = 0; i < 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (let i = 0; i < 2 * n; i++) {\n        for (let j = 0; j < n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n
    function algorithm(n: number): void {\n    let a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (let i = 0; i < 5 * n + 1; i++) {\n        console.log(0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (let i = 0; i < 2 * n; i++) {\n        for (let j = 0; j < n + 1; j++) {\n            console.log(0);\n        }\n    }\n}\n
    void algorithm(int n) {\n  int a = 1; // +0\uff08\u6280\u5de7 1\uff09\n  a = a + n; // +0\uff08\u6280\u5de7 1\uff09\n  // +n\uff08\u6280\u5de7 2\uff09\n  for (int i = 0; i < 5 * n + 1; i++) {\n    print(0);\n  }\n  // +n*n\uff08\u6280\u5de7 3\uff09\n  for (int i = 0; i < 2 * n; i++) {\n    for (int j = 0; j < n + 1; j++) {\n      print(0);\n    }\n  }\n}\n
    fn algorithm(n: i32) {\n    let mut a = 1;     // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;        // +0\uff08\u6280\u5de7 1\uff09\n\n    // +n\uff08\u6280\u5de7 2\uff09\n    for i in 0..(5 * n + 1) {\n        println!(\"{}\", 0);\n    }\n\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for i in 0..(2 * n) {\n        for j in 0..(n + 1) {\n            println!(\"{}\", 0);\n        }\n    }\n}\n
    void algorithm(int n) {\n    int a = 1;  // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n;  // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (int i = 0; i < 5 * n + 1; i++) {\n        printf(\"%d\", 0);\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (int i = 0; i < 2 * n; i++) {\n        for (int j = 0; j < n + 1; j++) {\n            printf(\"%d\", 0);\n        }\n    }\n}\n
    fun algorithm(n: Int) {\n    var a = 1   // +0\uff08\u6280\u5de7 1\uff09\n    a = a + n   // +0\uff08\u6280\u5de7 1\uff09\n    // +n\uff08\u6280\u5de7 2\uff09\n    for (i in 0..<5 * n + 1) {\n        println(0)\n    }\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for (i in 0..<2 * n) {\n        for (j in 0..<n + 1) {\n            println(0)\n        }\n    }\n}\n
    \n
    fn algorithm(n: usize) void {\n    var a: i32 = 1;     // +0\uff08\u6280\u5de7 1\uff09\n    a = a + @as(i32, @intCast(n));        // +0\uff08\u6280\u5de7 1\uff09\n\n    // +n\uff08\u6280\u5de7 2\uff09\n    for(0..(5 * n + 1)) |_| {\n        std.debug.print(\"{}\\n\", .{0}); \n    }\n\n    // +n*n\uff08\u6280\u5de7 3\uff09\n    for(0..(2 * n)) |_| {\n        for(0..(n + 1)) |_| {\n            std.debug.print(\"{}\\n\", .{0}); \n        }\n    }\n}\n

    \u4ee5\u4e0b\u516c\u5f0f\u5c55\u793a\u4e86\u4f7f\u7528\u4e0a\u8ff0\u6280\u5de7\u524d\u540e\u7684\u7edf\u8ba1\u7ed3\u679c\uff0c\u4e24\u8005\u63a8\u7b97\u51fa\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n^2)\\) \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} \\]"},{"location":"chapter_computational_complexity/time_complexity/#2","title":"2. \u00a0 \u7b2c\u4e8c\u6b65\uff1a\u5224\u65ad\u6e10\u8fd1\u4e0a\u754c","text":"

    \u65f6\u95f4\u590d\u6742\u5ea6\u7531 \\(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\u5ffd\u7565\u3002

    \u8868 2-2 \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

    \u8868 2-2 \u00a0 \u4e0d\u540c\u64cd\u4f5c\u6570\u91cf\u5bf9\u5e94\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \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/#234","title":"2.3.4 \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\u5982\u56fe 2-9 \u6240\u793a\uff08\u6309\u7167\u4ece\u4f4e\u5230\u9ad8\u7684\u987a\u5e8f\u6392\u5217\uff09\u3002

    \\[ \\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} \\]

    \u56fe 2-9 \u00a0 \u5e38\u89c1\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7c7b\u578b

    "},{"location":"chapter_computational_complexity/time_complexity/#1-o1","title":"1. \u00a0 \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

    \u5728\u4ee5\u4e0b\u51fd\u6570\u4e2d\uff0c\u5c3d\u7ba1\u64cd\u4f5c\u6570\u91cf size \u53ef\u80fd\u5f88\u5927\uff0c\u4f46\u7531\u4e8e\u5176\u4e0e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u65e0\u5173\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4ecd\u4e3a \\(O(1)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def constant(n: int) -> int:\n    \"\"\"\u5e38\u6570\u9636\"\"\"\n    count = 0\n    size = 100000\n    for _ in range(size):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.java
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.cs
    /* \u5e38\u6570\u9636 */\nint Constant(int n) {\n    int count = 0;\n    int size = 100000;\n    for (int i = 0; i < size; i++)\n        count++;\n    return count;\n}\n
    time_complexity.go
    /* \u5e38\u6570\u9636 */\nfunc constant(n int) int {\n    count := 0\n    size := 100000\n    for i := 0; i < size; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e38\u6570\u9636 */\nfunc constant(n: Int) -> Int {\n    var count = 0\n    let size = 100_000\n    for _ in 0 ..< size {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e38\u6570\u9636 */\nfunction constant(n) {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i < size; i++) count++;\n    return count;\n}\n
    time_complexity.ts
    /* \u5e38\u6570\u9636 */\nfunction constant(n: number): number {\n    let count = 0;\n    const size = 100000;\n    for (let i = 0; i < size; i++) count++;\n    return count;\n}\n
    time_complexity.dart
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n  int count = 0;\n  int size = 100000;\n  for (var i = 0; i < size; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e38\u6570\u9636 */\nfn constant(n: i32) -> i32 {\n    _ = n;\n    let mut count = 0;\n    let size = 100_000;\n    for _ in 0..size {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e38\u6570\u9636 */\nint constant(int n) {\n    int count = 0;\n    int size = 100000;\n    int i = 0;\n    for (int i = 0; i < size; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e38\u6570\u9636 */\nfun constant(n: Int): Int {\n    var count = 0\n    val size = 10_0000\n    for (i in 0..<size)\n        count++\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{constant}\n
    time_complexity.zig
    // \u5e38\u6570\u9636\nfn constant(n: i32) i32 {\n    _ = n;\n    var count: i32 = 0;\n    const size: i32 = 100_000;\n    var i: i32 = 0;\n    while(i<size) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_computational_complexity/time_complexity/#2-on","title":"2. \u00a0 \u7ebf\u6027\u9636 \\(O(n)\\)","text":"

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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def linear(n: int) -> int:\n    \"\"\"\u7ebf\u6027\u9636\"\"\"\n    count = 0\n    for _ in range(n):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636 */\nint Linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++)\n        count++;\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u9636 */\nfunc linear(n int) int {\n    count := 0\n    for i := 0; i < n; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636 */\nfunc linear(n: Int) -> Int {\n    var count = 0\n    for _ in 0 ..< n {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636 */\nfunction linear(n) {\n    let count = 0;\n    for (let i = 0; i < n; i++) count++;\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636 */\nfunction linear(n: number): number {\n    let count = 0;\n    for (let i = 0; i < n; i++) count++;\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n  int count = 0;\n  for (var i = 0; i < n; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u9636 */\nfn linear(n: i32) -> i32 {\n    let mut count = 0;\n    for _ in 0..n {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636 */\nint linear(int n) {\n    int count = 0;\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u9636 */\nfun linear(n: Int): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (i in 0..<n)\n        count++\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{linear}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\nfn linear(n: i32) i32 {\n    var count: i32 = 0;\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def array_traversal(nums: list[int]) -> int:\n    \"\"\"\u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\"\"\"\n    count = 0\n    # \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for num in nums:\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(vector<int> &nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int[] nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int num : nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint ArrayTraversal(int[] nums) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    foreach (int num in nums) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums []int) int {\n    count := 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for range nums {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunc arrayTraversal(nums: [Int]) -> Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for _ in nums {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums) {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (let i = 0; i < nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfunction arrayTraversal(nums: number[]): number {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (let i = 0; i < nums.length; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(List<int> nums) {\n  int count = 0;\n  // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n  for (var _num in nums) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfn array_traversal(nums: &[i32]) -> i32 {\n    let mut count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for _ in nums {\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nint arrayTraversal(int *nums, int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09 */\nfun arrayTraversal(nums: IntArray): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (num in nums) {\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{array_traversal}\n
    time_complexity.zig
    // \u7ebf\u6027\u9636\uff08\u904d\u5386\u6570\u7ec4\uff09\nfn arrayTraversal(nums: []i32) i32 {\n    var count: i32 = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u7ec4\u957f\u5ea6\u6210\u6b63\u6bd4\n    for (nums) |_| {\n        count += 1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \u9700\u6839\u636e\u8f93\u5165\u6570\u636e\u7684\u7c7b\u578b\u6765\u5177\u4f53\u786e\u5b9a\u3002\u6bd4\u5982\u5728\u7b2c\u4e00\u4e2a\u793a\u4f8b\u4e2d\uff0c\u53d8\u91cf \\(n\\) \u4e3a\u8f93\u5165\u6570\u636e\u5927\u5c0f\uff1b\u5728\u7b2c\u4e8c\u4e2a\u793a\u4f8b\u4e2d\uff0c\u6570\u7ec4\u957f\u5ea6 \\(n\\) \u4e3a\u6570\u636e\u5927\u5c0f\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#3-on2","title":"3. \u00a0 \u5e73\u65b9\u9636 \\(O(n^2)\\)","text":"

    \u5e73\u65b9\u9636\u7684\u64cd\u4f5c\u6570\u91cf\u76f8\u5bf9\u4e8e\u8f93\u5165\u6570\u636e\u5927\u5c0f \\(n\\) \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\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u90fd\u4e3a \\(O(n)\\) \uff0c\u56e0\u6b64\u603b\u4f53\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def quadratic(n: int) -> int:\n    \"\"\"\u5e73\u65b9\u9636\"\"\"\n    count = 0\n    # \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for i in range(n):\n        for j in range(n):\n            count += 1\n    return count\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636 */\nint Quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n int) int {\n    count := 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for i := 0; i < n; i++ {\n        for j := 0; j < n; j++ {\n            count++\n        }\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636 */\nfunc quadratic(n: Int) -> Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for _ in 0 ..< n {\n        for _ in 0 ..< n {\n            count += 1\n        }\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n) {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636 */\nfunction quadratic(n: number): number {\n    let count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n  int count = 0;\n  // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n  for (int i = 0; i < n; i++) {\n    for (int j = 0; j < n; j++) {\n      count++;\n    }\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e73\u65b9\u9636 */\nfn quadratic(n: i32) -> i32 {\n    let mut count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for _ in 0..n {\n        for _ in 0..n {\n            count += 1;\n        }\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636 */\nint quadratic(int n) {\n    int count = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < n; j++) {\n            count++;\n        }\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e73\u65b9\u9636 */\nfun quadratic(n: Int): Int {\n    var count = 0\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    for (i in 0..<n) {\n        for (j in 0..<n) {\n            count++\n        }\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{quadratic}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\nfn quadratic(n: i32) i32 {\n    var count: i32 = 0;\n    var i: i32 = 0;\n    // \u5faa\u73af\u6b21\u6570\u4e0e\u6570\u636e\u5927\u5c0f n \u6210\u5e73\u65b9\u5173\u7cfb\n    while (i < n) : (i += 1) {\n        var j: i32 = 0;\n        while (j < n) : (j += 1) {\n            count += 1;\n        }\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-10 \u5bf9\u6bd4\u4e86\u5e38\u6570\u9636\u3001\u7ebf\u6027\u9636\u548c\u5e73\u65b9\u9636\u4e09\u79cd\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    \u56fe 2-10 \u00a0 \u5e38\u6570\u9636\u3001\u7ebf\u6027\u9636\u548c\u5e73\u65b9\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u4ee5\u5192\u6ce1\u6392\u5e8f\u4e3a\u4f8b\uff0c\u5916\u5c42\u5faa\u73af\u6267\u884c \\(n - 1\\) \u6b21\uff0c\u5185\u5c42\u5faa\u73af\u6267\u884c \\(n-1\\)\u3001\\(n-2\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \u6b21\uff0c\u5e73\u5747\u4e3a \\(n / 2\\) \u6b21\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O((n - 1) n / 2) = O(n^2)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def bubble_sort(nums: list[int]) -> int:\n    \"\"\"\u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\"\"\"\n    count = 0  # \u8ba1\u6570\u5668\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j in range(i):\n            if nums[j] > nums[j + 1]:\n                # \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                tmp: int = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3  # \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n    return count\n
    time_complexity.cpp
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(vector<int> &nums) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int[] nums) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint BubbleSort(int[] nums) {\n    int count = 0;  // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                count += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums []int) int {\n    count := 0 // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j := 0; j < i; j++ {\n            if nums[j] > nums[j+1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                tmp := nums[j]\n                nums[j] = nums[j+1]\n                nums[j+1] = tmp\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunc bubbleSort(nums: inout [Int]) -> Int {\n    var count = 0 // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in nums.indices.dropFirst().reversed() {\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\n        for j in 0 ..< i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j]\n                nums[j] = nums[j + 1]\n                nums[j + 1] = tmp\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums) {\n    let count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfunction bubbleSort(nums: number[]): number {\n    let count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(List<int> nums) {\n  int count = 0; // \u8ba1\u6570\u5668\n  // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n  for (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\n    for (var j = 0; j < i; j++) {\n      if (nums[j] > nums[j + 1]) {\n        // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n      }\n    }\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfn bubble_sort(nums: &mut [i32]) -> i32 {\n    let mut count = 0; // \u8ba1\u6570\u5668\n\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in (1..nums.len()).rev() {\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\n        for j in 0..i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    count\n}\n
    time_complexity.c
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nint bubbleSort(int *nums, int n) {\n    int count = 0; // \u8ba1\u6570\u5668\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3; // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09 */\nfun bubbleSort(nums: IntArray): Int {\n    var count = 0\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (i in nums.size - 1 downTo 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\n        for (j in 0..<i) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j] = nums[j + 1].also { nums[j + 1] = nums[j] }\n                count += 3 // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{bubble_sort}\n
    time_complexity.zig
    // \u5e73\u65b9\u9636\uff08\u5192\u6ce1\u6392\u5e8f\uff09\nfn bubbleSort(nums: []i32) i32 {\n    var count: i32 = 0;  // \u8ba1\u6570\u5668 \n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    var i: i32 = @as(i32, @intCast(nums.len)) - 1;\n    while (i > 0) : (i -= 1) {\n        var 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\n        while (j < i) : (j += 1) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                var tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                count += 3;  // \u5143\u7d20\u4ea4\u6362\u5305\u542b 3 \u4e2a\u5355\u5143\u64cd\u4f5c\n            }\n        }\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_computational_complexity/time_complexity/#4-o2n","title":"4. \u00a0 \u6307\u6570\u9636 \\(O(2^n)\\)","text":"

    \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

    \u56fe 2-11 \u548c\u4ee5\u4e0b\u4ee3\u7801\u6a21\u62df\u4e86\u7ec6\u80de\u5206\u88c2\u7684\u8fc7\u7a0b\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def exponential(n: int) -> int:\n    \"\"\"\u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\n    count = 0\n    base = 1\n    # \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in range(n):\n        for _ in range(base):\n            count += 1\n        base *= 2\n    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.java
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0, base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.cs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint Exponential(int n) {\n    int count = 0, bas = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc exponential(n int) int {\n    count, base := 0, 1\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for i := 0; i < n; i++ {\n        for j := 0; j < base; j++ {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.swift
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc exponential(n: Int) -> Int {\n    var count = 0\n    var base = 1\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0 ..< n {\n        for _ in 0 ..< base {\n            count += 1\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n) {\n    let count = 0,\n        base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.ts
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction exponential(n: number): number {\n    let count = 0,\n        base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < base; j++) {\n            count++;\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.dart
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n  int count = 0, base = 1;\n  // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n  for (var i = 0; i < n; i++) {\n    for (var j = 0; j < base; j++) {\n      count++;\n    }\n    base *= 2;\n  }\n  // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n  return count;\n}\n
    time_complexity.rs
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfn exponential(n: i32) -> i32 {\n    let mut count = 0;\n    let mut base = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for _ in 0..n {\n        for _ in 0..base {\n            count += 1\n        }\n        base *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    count\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint exponential(int n) {\n    int count = 0;\n    int bas = 1;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    for (int i = 0; i < n; i++) {\n        for (int j = 0; j < bas; j++) {\n            count++;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    time_complexity.kt
    /* \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfun exponential(n: Int): Int {\n    var count = 0\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    var base = 1\n    for (i in 0..<n) {\n        for (j in 0..<base) {\n            count++\n        }\n        base *= 2\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{exponential}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn exponential(n: i32) i32 {\n    var count: i32 = 0;\n    var bas: i32 = 1;\n    var i: i32 = 0;\n    // \u7ec6\u80de\u6bcf\u8f6e\u4e00\u5206\u4e3a\u4e8c\uff0c\u5f62\u6210\u6570\u5217 1, 2, 4, 8, ..., 2^(n-1)\n    while (i < n) : (i += 1) {\n        var j: i32 = 0;\n        while (j < bas) : (j += 1) {\n            count += 1;\n        }\n        bas *= 2;\n    }\n    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-11 \u00a0 \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\u4e2d\u3002\u4f8b\u5982\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u5176\u9012\u5f52\u5730\u4e00\u5206\u4e3a\u4e8c\uff0c\u7ecf\u8fc7 \\(n\\) \u6b21\u5206\u88c2\u540e\u505c\u6b62\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def exp_recur(n: int) -> int:\n    \"\"\"\u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n == 1:\n        return 1\n    return exp_recur(n - 1) + exp_recur(n - 1) + 1\n
    time_complexity.cpp
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.java
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return 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) {\n    if (n == 1) return 1;\n    return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;\n}\n
    time_complexity.go
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc expRecur(n int) int {\n    if n == 1 {\n        return 1\n    }\n    return 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 {\n    if n == 1 {\n        return 1\n    }\n    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1\n}\n
    time_complexity.js
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction expRecur(n) {\n    if (n === 1) return 1;\n    return 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 {\n    if (n === 1) return 1;\n    return 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) {\n  if (n == 1) return 1;\n  return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.rs
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn exp_recur(n: i32) -> i32 {\n    if n == 1 {\n        return 1;\n    }\n    exp_recur(n - 1) + exp_recur(n - 1) + 1\n}\n
    time_complexity.c
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint expRecur(int n) {\n    if (n == 1)\n        return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    time_complexity.kt
    /* \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun expRecur(n: Int): Int {\n    if (n == 1) {\n        return 1\n    }\n    return expRecur(n - 1) + expRecur(n - 1) + 1\n}\n
    time_complexity.rb
    [class]{}-[func]{exp_recur}\n
    time_complexity.zig
    // \u6307\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn expRecur(n: i32) i32 {\n    if (n == 1) return 1;\n    return expRecur(n - 1) + expRecur(n - 1) + 1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6307\u6570\u9636\u589e\u957f\u975e\u5e38\u8fc5\u901f\uff0c\u5728\u7a77\u4e3e\u6cd5\uff08\u66b4\u529b\u641c\u7d22\u3001\u56de\u6eaf\u7b49\uff09\u4e2d\u6bd4\u8f83\u5e38\u89c1\u3002\u5bf9\u4e8e\u6570\u636e\u89c4\u6a21\u8f83\u5927\u7684\u95ee\u9898\uff0c\u6307\u6570\u9636\u662f\u4e0d\u53ef\u63a5\u53d7\u7684\uff0c\u901a\u5e38\u9700\u8981\u4f7f\u7528\u52a8\u6001\u89c4\u5212\u6216\u8d2a\u5fc3\u7b97\u6cd5\u7b49\u6765\u89e3\u51b3\u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#5-olog-n","title":"5. \u00a0 \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\u201d\u7684\u60c5\u51b5\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

    \u56fe 2-12 \u548c\u4ee5\u4e0b\u4ee3\u7801\u6a21\u62df\u4e86\u201c\u6bcf\u8f6e\u7f29\u51cf\u5230\u4e00\u534a\u201d\u7684\u8fc7\u7a0b\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log_2 n)\\) \uff0c\u7b80\u8bb0\u4e3a \\(O(\\log n)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def logarithmic(n: int) -> int:\n    \"\"\"\u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\"\"\"\n    count = 0\n    while n > 1:\n        n = n / 2\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint Logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n /= 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09*/\nfunc logarithmic(n int) int {\n    count := 0\n    for n > 1 {\n        n = n / 2\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunc logarithmic(n: Int) -> Int {\n    var count = 0\n    var n = n\n    while n > 1 {\n        n = n / 2\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n) {\n    let count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfunction logarithmic(n: number): number {\n    let count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n  int count = 0;\n  while (n > 1) {\n    n = n ~/ 2;\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfn logarithmic(mut n: i32) -> i32 {\n    let mut count = 0;\n    while n > 1 {\n        n = n / 2;\n        count += 1;\n    }\n    count\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nint logarithmic(int n) {\n    int count = 0;\n    while (n > 1) {\n        n = n / 2;\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09 */\nfun logarithmic(n: Int): Int {\n    var n1 = n\n    var count = 0\n    while (n1 > 1) {\n        n1 /= 2\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{logarithmic}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u5faa\u73af\u5b9e\u73b0\uff09\nfn logarithmic(n: i32) i32 {\n    var count: i32 = 0;\n    var n_var = n;\n    while (n_var > 1)\n    {\n        n_var = n_var / 2;\n        count +=1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-12 \u00a0 \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\u4e2d\u3002\u4ee5\u4e0b\u4ee3\u7801\u5f62\u6210\u4e86\u4e00\u68f5\u9ad8\u5ea6\u4e3a \\(\\log_2 n\\) \u7684\u9012\u5f52\u6811\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def log_recur(n: int) -> int:\n    \"\"\"\u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n <= 1:\n        return 0\n    return log_recur(n / 2) + 1\n
    time_complexity.cpp
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.java
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.cs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint LogRecur(int n) {\n    if (n <= 1) return 0;\n    return LogRecur(n / 2) + 1;\n}\n
    time_complexity.go
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09*/\nfunc logRecur(n int) int {\n    if n <= 1 {\n        return 0\n    }\n    return logRecur(n/2) + 1\n}\n
    time_complexity.swift
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc logRecur(n: Int) -> Int {\n    if n <= 1 {\n        return 0\n    }\n    return logRecur(n: n / 2) + 1\n}\n
    time_complexity.js
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n) {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.ts
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction logRecur(n: number): number {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.dart
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n  if (n <= 1) return 0;\n  return logRecur(n ~/ 2) + 1;\n}\n
    time_complexity.rs
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn log_recur(n: i32) -> i32 {\n    if n <= 1 {\n        return 0;\n    }\n    log_recur(n / 2) + 1\n}\n
    time_complexity.c
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint logRecur(int n) {\n    if (n <= 1)\n        return 0;\n    return logRecur(n / 2) + 1;\n}\n
    time_complexity.kt
    /* \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun logRecur(n: Int): Int {\n    if (n <= 1)\n        return 0\n    return logRecur(n / 2) + 1\n}\n
    time_complexity.rb
    [class]{}-[func]{log_recur}\n
    time_complexity.zig
    // \u5bf9\u6570\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn logRecur(n: i32) i32 {\n    if (n <= 1) return 0;\n    return logRecur(n / 2) + 1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5bf9\u6570\u9636\u5e38\u51fa\u73b0\u4e8e\u57fa\u4e8e\u5206\u6cbb\u7b56\u7565\u7684\u7b97\u6cd5\u4e2d\uff0c\u4f53\u73b0\u4e86\u201c\u4e00\u5206\u4e3a\u591a\u201d\u548c\u201c\u5316\u7e41\u4e3a\u7b80\u201d\u7684\u7b97\u6cd5\u601d\u60f3\u3002\u5b83\u589e\u957f\u7f13\u6162\uff0c\u662f\u4ec5\u6b21\u4e8e\u5e38\u6570\u9636\u7684\u7406\u60f3\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    \\(O(\\log n)\\) \u7684\u5e95\u6570\u662f\u591a\u5c11\uff1f

    \u51c6\u786e\u6765\u8bf4\uff0c\u201c\u4e00\u5206\u4e3a \\(m\\)\u201d\u5bf9\u5e94\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f \\(O(\\log_m n)\\) \u3002\u800c\u901a\u8fc7\u5bf9\u6570\u6362\u5e95\u516c\u5f0f\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u5230\u5177\u6709\u4e0d\u540c\u5e95\u6570\u3001\u76f8\u7b49\u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff1a

    \\[ O(\\log_m n) = O(\\log_k n / \\log_k m) = O(\\log_k n) \\]

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5e95\u6570 \\(m\\) \u53ef\u4ee5\u5728\u4e0d\u5f71\u54cd\u590d\u6742\u5ea6\u7684\u524d\u63d0\u4e0b\u8f6c\u6362\u3002\u56e0\u6b64\u6211\u4eec\u901a\u5e38\u4f1a\u7701\u7565\u5e95\u6570 \\(m\\) \uff0c\u5c06\u5bf9\u6570\u9636\u76f4\u63a5\u8bb0\u4e3a \\(O(\\log n)\\) \u3002

    "},{"location":"chapter_computational_complexity/time_complexity/#6-on-log-n","title":"6. \u00a0 \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\u76f8\u5173\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def linear_log_recur(n: int) -> int:\n    \"\"\"\u7ebf\u6027\u5bf9\u6570\u9636\"\"\"\n    if n <= 1:\n        return 1\n    count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)\n    for _ in range(n):\n        count += 1\n    return count\n
    time_complexity.cpp
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint LinearLogRecur(int n) {\n    if (n <= 1) return 1;\n    int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n int) int {\n    if n <= 1 {\n        return 1\n    }\n    count := linearLogRecur(n/2) + linearLogRecur(n/2)\n    for i := 0; i < n; i++ {\n        count++\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunc linearLogRecur(n: Int) -> Int {\n    if n <= 1 {\n        return 1\n    }\n    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)\n    for _ in stride(from: 0, to: n, by: 1) {\n        count += 1\n    }\n    return count\n}\n
    time_complexity.js
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n) {\n    if (n <= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfunction linearLogRecur(n: number): number {\n    if (n <= 1) return 1;\n    let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (let i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n  if (n <= 1) return 1;\n  int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);\n  for (var i = 0; i < n; i++) {\n    count++;\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfn linear_log_recur(n: i32) -> i32 {\n    if n <= 1 {\n        return 1;\n    }\n    let mut count = linear_log_recur(n / 2) + linear_log_recur(n / 2);\n    for _ in 0..n as i32 {\n        count += 1;\n    }\n    return count;\n}\n
    time_complexity.c
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nint linearLogRecur(int n) {\n    if (n <= 1)\n        return 1;\n    int count = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    for (int i = 0; i < n; i++) {\n        count++;\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u7ebf\u6027\u5bf9\u6570\u9636 */\nfun linearLogRecur(n: Int): Int {\n    if (n <= 1)\n        return 1\n    var count = linearLogRecur(n / 2) + linearLogRecur(n / 2)\n    for (i in 0..<n.toInt()) {\n        count++\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{linear_log_recur}\n
    time_complexity.zig
    // \u7ebf\u6027\u5bf9\u6570\u9636\nfn linearLogRecur(n: i32) i32 {\n    if (n <= 1) return 1;\n    var count: i32 = linearLogRecur(n / 2) + linearLogRecur(n / 2);\n    var i: i32 = 0;\n    while (i < n) : (i += 1) {\n        count += 1;\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-13 \u5c55\u793a\u4e86\u7ebf\u6027\u5bf9\u6570\u9636\u7684\u751f\u6210\u65b9\u5f0f\u3002\u4e8c\u53c9\u6811\u7684\u6bcf\u4e00\u5c42\u7684\u64cd\u4f5c\u603b\u6570\u90fd\u4e3a \\(n\\) \uff0c\u6811\u5171\u6709 \\(\\log_2 n + 1\\) \u5c42\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    \u56fe 2-13 \u00a0 \u7ebf\u6027\u5bf9\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \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

    "},{"location":"chapter_computational_complexity/time_complexity/#7-on","title":"7. \u00a0 \u9636\u4e58\u9636 \\(O(n!)\\)","text":"

    \u9636\u4e58\u9636\u5bf9\u5e94\u6570\u5b66\u4e0a\u7684\u201c\u5168\u6392\u5217\u201d\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 \\dots \\times 2 \\times 1 \\]

    \u9636\u4e58\u901a\u5e38\u4f7f\u7528\u9012\u5f52\u5b9e\u73b0\u3002\u5982\u56fe 2-14 \u548c\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\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\u505c\u6b62\u5206\u88c2\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig time_complexity.py
    def factorial_recur(n: int) -> int:\n    \"\"\"\u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\"\"\"\n    if n == 0:\n        return 1\n    count = 0\n    # \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in range(n):\n        count += factorial_recur(n - 1)\n    return count\n
    time_complexity.cpp
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.java
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.cs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint FactorialRecur(int n) {\n    if (n == 0) return 1;\n    int count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (int i = 0; i < n; i++) {\n        count += FactorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.go
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n int) int {\n    if n == 0 {\n        return 1\n    }\n    count := 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for i := 0; i < n; i++ {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n
    time_complexity.swift
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunc factorialRecur(n: Int) -> Int {\n    if n == 0 {\n        return 1\n    }\n    var count = 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in 0 ..< n {\n        count += factorialRecur(n: n - 1)\n    }\n    return count\n}\n
    time_complexity.js
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n) {\n    if (n === 0) return 1;\n    let count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (let i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.ts
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfunction factorialRecur(n: number): number {\n    if (n === 0) return 1;\n    let count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (let i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.dart
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n  if (n == 0) return 1;\n  int count = 0;\n  // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n  for (var i = 0; i < n; i++) {\n    count += factorialRecur(n - 1);\n  }\n  return count;\n}\n
    time_complexity.rs
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfn factorial_recur(n: i32) -> i32 {\n    if n == 0 {\n        return 1;\n    }\n    let mut count = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for _ in 0..n {\n        count += factorial_recur(n - 1);\n    }\n    count\n}\n
    time_complexity.c
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nint factorialRecur(int n) {\n    if (n == 0)\n        return 1;\n    int count = 0;\n    for (int i = 0; i < n; i++) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    time_complexity.kt
    /* \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09 */\nfun factorialRecur(n: Int): Int {\n    if (n == 0)\n        return 1\n    var count = 0\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    for (i in 0..<n) {\n        count += factorialRecur(n - 1)\n    }\n    return count\n}\n
    time_complexity.rb
    [class]{}-[func]{factorial_recur}\n
    time_complexity.zig
    // \u9636\u4e58\u9636\uff08\u9012\u5f52\u5b9e\u73b0\uff09\nfn factorialRecur(n: i32) i32 {\n    if (n == 0) return 1;\n    var count: i32 = 0;\n    var i: i32 = 0;\n    // \u4ece 1 \u4e2a\u5206\u88c2\u51fa n \u4e2a\n    while (i < n) : (i += 1) {\n        count += factorialRecur(n - 1);\n    }\n    return count;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 2-14 \u00a0 \u9636\u4e58\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6

    \u8bf7\u6ce8\u610f\uff0c\u56e0\u4e3a\u5f53 \\(n \\geq 4\\) \u65f6\u6052\u6709 \\(n! > 2^n\\) \uff0c\u6240\u4ee5\u9636\u4e58\u9636\u6bd4\u6307\u6570\u9636\u589e\u957f\u5f97\u66f4\u5feb\uff0c\u5728 \\(n\\) \u8f83\u5927\u65f6\u4e5f\u662f\u4e0d\u53ef\u63a5\u53d7\u7684\u3002

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

    \u7b97\u6cd5\u7684\u65f6\u95f4\u6548\u7387\u5f80\u5f80\u4e0d\u662f\u56fa\u5b9a\u7684\uff0c\u800c\u662f\u4e0e\u8f93\u5165\u6570\u636e\u7684\u5206\u5e03\u6709\u5173\u3002\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\u6bcf\u4e2a\u6570\u5b57\u53ea\u51fa\u73b0\u4e00\u6b21\uff1b\u4f46\u5143\u7d20\u987a\u5e8f\u662f\u968f\u673a\u6253\u4e71\u7684\uff0c\u4efb\u52a1\u76ee\u6807\u662f\u8fd4\u56de\u5143\u7d20 \\(1\\) \u7684\u7d22\u5f15\u3002\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u4ee5\u4e0b\u7ed3\u8bba\u3002

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

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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    nums = [i for i in range(1, n + 1)]\n    # \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    random.shuffle(nums)\n    return nums\n\ndef find_one(nums: list[int]) -> int:\n    \"\"\"\u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\"\"\"\n    for 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)\n        if nums[i] == 1:\n            return i\n    return -1\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) {\n    vector<int> nums(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u4f7f\u7528\u7cfb\u7edf\u65f6\u95f4\u751f\u6210\u968f\u673a\u79cd\u5b50\n    unsigned seed = chrono::system_clock::now().time_since_epoch().count();\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    shuffle(nums.begin(), nums.end(), default_random_engine(seed));\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(vector<int> &nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n
    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) {\n    Integer[] nums = new Integer[n];\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    Collections.shuffle(Arrays.asList(nums));\n    // Integer[] -> int[]\n    int[] res = new int[n];\n    for (int i = 0; i < n; i++) {\n        res[i] = nums[i];\n    }\n    return res;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int[] nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -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) {\n    int[] nums = new int[n];\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (int i = 0; i < nums.Length; i++) {\n        int index = new Random().Next(i, nums.Length);\n        (nums[i], nums[index]) = (nums[index], nums[i]);\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint FindOne(int[] nums) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\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 {\n    nums := make([]int, n)\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for i := 0; i < n; i++ {\n        nums[i] = i + 1\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    rand.Shuffle(len(nums), func(i, j int) {\n        nums[i], nums[j] = nums[j], nums[i]\n    })\n    return nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums []int) int {\n    for 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)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -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 }\n    var nums = Array(1 ... n)\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    nums.shuffle()\n    return nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunc findOne(nums: [Int]) -> Int {\n    for 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)\n        if nums[i] == 1 {\n            return i\n        }\n    }\n    return -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) {\n    const nums = Array(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (let i = 0; i < n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums) {\n    for (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)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -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[] {\n    const nums = Array(n);\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (let i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (let i = 0; i < n; i++) {\n        const r = Math.floor(Math.random() * (i + 1));\n        const temp = nums[i];\n        nums[i] = nums[r];\n        nums[r] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfunction findOne(nums: number[]): number {\n    for (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)\n        if (nums[i] === 1) {\n            return i;\n        }\n    }\n    return -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) {\n  final nums = List.filled(n, 0);\n  // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n  for (var i = 0; i < n; i++) {\n    nums[i] = i + 1;\n  }\n  // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n  nums.shuffle();\n\n  return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(List<int> nums) {\n  for (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)\n    if (nums[i] == 1) return i;\n  }\n\n  return -1;\n}\n
    worst_best_time_complexity.rs
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfn random_numbers(n: i32) -> Vec<i32> {\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    let mut nums = (1..=n).collect::<Vec<i32>>();\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    nums.shuffle(&mut thread_rng());\n    nums\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfn find_one(nums: &[i32]) -> Option<usize> {\n    for i in 0..nums.len() {\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)\n        if nums[i] == 1 {\n            return Some(i);\n        }\n    }\n    None\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\u4e3a n \uff0c\u5143\u7d20\u7c7b\u578b\u4e3a int \uff09\n    int *nums = (int *)malloc(n * sizeof(int));\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (int i = 0; i < n; i++) {\n        nums[i] = i + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    for (int i = n - 1; i > 0; i--) {\n        int j = rand() % (i + 1);\n        int temp = nums[i];\n        nums[i] = nums[j];\n        nums[j] = temp;\n    }\n    return nums;\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nint findOne(int *nums, int n) {\n    for (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)\n        if (nums[i] == 1)\n            return i;\n    }\n    return -1;\n}\n
    worst_best_time_complexity.kt
    /* \u751f\u6210\u4e00\u4e2a\u6570\u7ec4\uff0c\u5143\u7d20\u4e3a { 1, 2, ..., n }\uff0c\u987a\u5e8f\u88ab\u6253\u4e71 */\nfun randomNumbers(n: Int): Array<Int?> {\n    val nums = IntArray(n)\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (i in 0..<n) {\n        nums[i] = i + 1\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    val mutableList = nums.toMutableList()\n    mutableList.shuffle()\n    // Integer[] -> int[]\n    val res = arrayOfNulls<Int>(n)\n    for (i in 0..<n) {\n        res[i] = mutableList[i]\n    }\n    return res\n}\n\n/* \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15 */\nfun findOne(nums: Array<Int?>): Int {\n    for (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)\n        if (nums[i] == 1)\n            return i\n    }\n    return -1\n}\n
    worst_best_time_complexity.rb
    [class]{}-[func]{random_numbers}\n\n[class]{}-[func]{find_one}\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\nfn randomNumbers(comptime n: usize) [n]i32 {\n    var nums: [n]i32 = undefined;\n    // \u751f\u6210\u6570\u7ec4 nums = { 1, 2, 3, ..., n }\n    for (&nums, 0..) |*num, i| {\n        num.* = @as(i32, @intCast(i)) + 1;\n    }\n    // \u968f\u673a\u6253\u4e71\u6570\u7ec4\u5143\u7d20\n    const rand = std.crypto.random;\n    rand.shuffle(i32, &nums);\n    return nums;\n}\n\n// \u67e5\u627e\u6570\u7ec4 nums \u4e2d\u6570\u5b57 1 \u6240\u5728\u7d22\u5f15\nfn findOne(nums: []i32) i32 {\n    for (nums, 0..) |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)\n        if (num == 1) return @intCast(i);\n    }\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u6211\u4eec\u5728\u5b9e\u9645\u4e2d\u5f88\u5c11\u4f7f\u7528\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\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\u800c\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\u66f4\u4e3a\u5b9e\u7528\uff0c\u56e0\u4e3a\u5b83\u7ed9\u51fa\u4e86\u4e00\u4e2a\u6548\u7387\u5b89\u5168\u503c\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\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u6700\u4f73\u65f6\u95f4\u590d\u6742\u5ea6\u53ea\u51fa\u73b0\u4e8e\u201c\u7279\u6b8a\u7684\u6570\u636e\u5206\u5e03\u201d\uff0c\u8fd9\u4e9b\u60c5\u51b5\u7684\u51fa\u73b0\u6982\u7387\u53ef\u80fd\u5f88\u5c0f\uff0c\u5e76\u4e0d\u80fd\u771f\u5b9e\u5730\u53cd\u6620\u7b97\u6cd5\u8fd0\u884c\u6548\u7387\u3002\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\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\u5c31\u662f\u6570\u7ec4\u957f\u5ea6\u7684\u4e00\u534a \\(n / 2\\) \uff0c\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(\\Theta(n / 2) = \\Theta(n)\\) \u3002

    \u4f46\u5bf9\u4e8e\u8f83\u4e3a\u590d\u6742\u7684\u7b97\u6cd5\uff0c\u8ba1\u7b97\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u5f80\u5f80\u6bd4\u8f83\u56f0\u96be\uff0c\u56e0\u4e3a\u5f88\u96be\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\u56e0\u6b64\u6211\u4eec\u5e38\u5e38\u4f7f\u7528\u5b83\u6765\u8868\u793a\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u3002\u4f46\u4ece\u4e25\u683c\u610f\u4e49\u4e0a\u8bb2\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":"\u7b2c 3 \u7ae0 \u00a0 \u6570\u636e\u7ed3\u6784","text":"

    Abstract

    \u6570\u636e\u7ed3\u6784\u5982\u540c\u4e00\u526f\u7a33\u56fa\u800c\u591a\u6837\u7684\u6846\u67b6\u3002

    \u5b83\u4e3a\u6570\u636e\u7684\u6709\u5e8f\u7ec4\u7ec7\u63d0\u4f9b\u4e86\u84dd\u56fe\uff0c\u7b97\u6cd5\u5f97\u4ee5\u5728\u6b64\u57fa\u7840\u4e0a\u751f\u52a8\u8d77\u6765\u3002

    "},{"location":"chapter_data_structure/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 3.1 \u00a0 \u6570\u636e\u7ed3\u6784\u5206\u7c7b
    • 3.2 \u00a0 \u57fa\u672c\u6570\u636e\u7c7b\u578b
    • 3.3 \u00a0 \u6570\u5b57\u7f16\u7801 *
    • 3.4 \u00a0 \u5b57\u7b26\u7f16\u7801 *
    • 3.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_data_structure/basic_data_types/","title":"3.2 \u00a0 \u57fa\u672c\u6570\u636e\u7c7b\u578b","text":"

    \u5f53\u8c08\u53ca\u8ba1\u7b97\u673a\u4e2d\u7684\u6570\u636e\u65f6\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\uff0c\u4e3b\u8981\u5305\u62ec\u4ee5\u4e0b\u51e0\u79cd\u3002

    • \u6574\u6570\u7c7b\u578b byte\u3001short\u3001int\u3001long \u3002
    • \u6d6e\u70b9\u6570\u7c7b\u578b float\u3001double \uff0c\u7528\u4e8e\u8868\u793a\u5c0f\u6570\u3002
    • \u5b57\u7b26\u7c7b\u578b char \uff0c\u7528\u4e8e\u8868\u793a\u5404\u79cd\u8bed\u8a00\u7684\u5b57\u6bcd\u3001\u6807\u70b9\u7b26\u53f7\u751a\u81f3\u8868\u60c5\u7b26\u53f7\u7b49\u3002
    • \u5e03\u5c14\u7c7b\u578b bool \uff0c\u7528\u4e8e\u8868\u793a\u201c\u662f\u201d\u4e0e\u201c\u5426\u201d\u5224\u65ad\u3002

    \u57fa\u672c\u6570\u636e\u7c7b\u578b\u4ee5\u4e8c\u8fdb\u5236\u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u4e2d\u3002\u4e00\u4e2a\u4e8c\u8fdb\u5236\u4f4d\u5373\u4e3a \\(1\\) \u6bd4\u7279\u3002\u5728\u7edd\u5927\u591a\u6570\u73b0\u4ee3\u64cd\u4f5c\u7cfb\u7edf\u4e2d\uff0c\\(1\\) \u5b57\u8282\uff08byte\uff09\u7531 \\(8\\) \u6bd4\u7279\uff08bit\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\u3002\u4e0b\u9762\u4ee5 Java \u4e3a\u4f8b\u3002

    • \u6574\u6570\u7c7b\u578b byte \u5360\u7528 \\(1\\) \u5b57\u8282 = \\(8\\) \u6bd4\u7279 \uff0c\u53ef\u4ee5\u8868\u793a \\(2^{8}\\) \u4e2a\u6570\u5b57\u3002
    • \u6574\u6570\u7c7b\u578b int \u5360\u7528 \\(4\\) \u5b57\u8282 = \\(32\\) \u6bd4\u7279 \uff0c\u53ef\u4ee5\u8868\u793a \\(2^{32}\\) \u4e2a\u6570\u5b57\u3002

    \u8868 3-1 \u5217\u4e3e\u4e86 Java \u4e2d\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\u987b\u6b7b\u8bb0\u786c\u80cc\uff0c\u5927\u81f4\u7406\u89e3\u5373\u53ef\uff0c\u9700\u8981\u65f6\u53ef\u4ee5\u901a\u8fc7\u67e5\u8868\u6765\u56de\u5fc6\u3002

    \u8868 3-1 \u00a0 \u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u5360\u7528\u7a7a\u95f4\u548c\u53d6\u503c\u8303\u56f4

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

    \u8bf7\u6ce8\u610f\uff0c\u8868 3-1 \u9488\u5bf9\u7684\u662f Java \u7684\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u60c5\u51b5\u3002\u6bcf\u79cd\u7f16\u7a0b\u8bed\u8a00\u90fd\u6709\u5404\u81ea\u7684\u6570\u636e\u7c7b\u578b\u5b9a\u4e49\uff0c\u5b83\u4eec\u7684\u5360\u7528\u7a7a\u95f4\u3001\u53d6\u503c\u8303\u56f4\u548c\u9ed8\u8ba4\u503c\u53ef\u80fd\u4f1a\u6709\u6240\u4e0d\u540c\u3002

    • \u5728 Python \u4e2d\uff0c\u6574\u6570\u7c7b\u578b int \u53ef\u4ee5\u662f\u4efb\u610f\u5927\u5c0f\uff0c\u53ea\u53d7\u9650\u4e8e\u53ef\u7528\u5185\u5b58\uff1b\u6d6e\u70b9\u6570 float \u662f\u53cc\u7cbe\u5ea6 64 \u4f4d\uff1b\u6ca1\u6709 char \u7c7b\u578b\uff0c\u5355\u4e2a\u5b57\u7b26\u5b9e\u9645\u4e0a\u662f\u957f\u5ea6\u4e3a 1 \u7684\u5b57\u7b26\u4e32 str \u3002
    • C \u548c C++ \u672a\u660e\u786e\u89c4\u5b9a\u57fa\u672c\u6570\u636e\u7c7b\u578b\u7684\u5927\u5c0f\uff0c\u800c\u56e0\u5b9e\u73b0\u548c\u5e73\u53f0\u5404\u5f02\u3002\u8868 3-1 \u9075\u5faa LP64 \u6570\u636e\u6a21\u578b\uff0c\u5176\u7528\u4e8e\u5305\u62ec Linux \u548c macOS \u5728\u5185\u7684 Unix 64 \u4f4d\u64cd\u4f5c\u7cfb\u7edf\u3002
    • \u5b57\u7b26 char \u7684\u5927\u5c0f\u5728 C \u548c C++ \u4e2d\u4e3a 1 \u5b57\u8282\uff0c\u5728\u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u4e2d\u53d6\u51b3\u4e8e\u7279\u5b9a\u7684\u5b57\u7b26\u7f16\u7801\u65b9\u6cd5\uff0c\u8be6\u89c1\u201c\u5b57\u7b26\u7f16\u7801\u201d\u7ae0\u8282\u3002
    • \u5373\u4f7f\u8868\u793a\u5e03\u5c14\u91cf\u4ec5\u9700 1 \u4f4d\uff08\\(0\\) \u6216 \\(1\\)\uff09\uff0c\u5b83\u5728\u5185\u5b58\u4e2d\u901a\u5e38\u4e5f\u5b58\u50a8\u4e3a 1 \u5b57\u8282\u3002\u8fd9\u662f\u56e0\u4e3a\u73b0\u4ee3\u8ba1\u7b97\u673a CPU \u901a\u5e38\u5c06 1 \u5b57\u8282\u4f5c\u4e3a\u6700\u5c0f\u5bfb\u5740\u5185\u5b58\u5355\u5143\u3002

    \u90a3\u4e48\uff0c\u57fa\u672c\u6570\u636e\u7c7b\u578b\u4e0e\u6570\u636e\u7ed3\u6784\u4e4b\u95f4\u6709\u4ec0\u4e48\u8054\u7cfb\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\u8fd9\u53e5\u8bdd\u7684\u4e3b\u8bed\u662f\u201c\u7ed3\u6784\u201d\u800c\u975e\u201c\u6570\u636e\u201d\u3002

    \u5982\u679c\u60f3\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 \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\u4f8b\u5982\u4ee5\u4e0b\u4ee3\u7801\uff0c\u6211\u4eec\u7528\u76f8\u540c\u7684\u6570\u636e\u7ed3\u6784\uff08\u6570\u7ec4\uff09\u6765\u5b58\u50a8\u4e0e\u8868\u793a\u4e0d\u540c\u7684\u57fa\u672c\u6570\u636e\u7c7b\u578b\uff0c\u5305\u62ec int\u3001float\u3001char\u3001bool \u7b49\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nnumbers: list[int] = [0] * 5\ndecimals: list[float] = [0.0] * 5\n# Python \u7684\u5b57\u7b26\u5b9e\u9645\u4e0a\u662f\u957f\u5ea6\u4e3a 1 \u7684\u5b57\u7b26\u4e32\ncharacters: list[str] = ['0'] * 5\nbools: list[bool] = [False] * 5\n# Python \u7684\u5217\u8868\u53ef\u4ee5\u81ea\u7531\u5b58\u50a8\u5404\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u548c\u5bf9\u8c61\u5f15\u7528\ndata = [0, 0.0, 'a', False, ListNode(0)]\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 bools[5];\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];\nboolean[] bools = new boolean[5];\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[] bools = new bool[5];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nvar numbers = [5]int{}\nvar decimals = [5]float64{}\nvar characters = [5]byte{}\nvar bools = [5]bool{}\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nlet numbers = Array(repeating: 0, count: 5)\nlet decimals = Array(repeating: 0.0, count: 5)\nlet characters: [Character] = Array(repeating: \"a\", count: 5)\nlet bools = Array(repeating: false, count: 5)\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 bools: boolean[] = [];\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> bools = List.filled(5, false);\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nlet numbers: Vec<i32> = vec![0; 5];\nlet decimals: Vec<f32> = vec![0.0; 5];\nlet characters: Vec<char> = vec!['0'; 5];\nlet bools: Vec<bool> = vec![false; 5];\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 bools[10];\n
    // \u4f7f\u7528\u591a\u79cd\u57fa\u672c\u6570\u636e\u7c7b\u578b\u6765\u521d\u59cb\u5316\u6570\u7ec4\nval numbers = IntArray(5)\nval decinals = FloatArray(5)\nval characters = CharArray(5)\nval bools = BooleanArray(5)\n
    \n
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u201c\u5b57\u7b26\u96c6\u201d\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\u5176\u5168\u79f0\u4e3a American Standard Code for Information Interchange\uff08\u7f8e\u56fd\u6807\u51c6\u4fe1\u606f\u4ea4\u6362\u4ee3\u7801\uff09\u3002\u5b83\u4f7f\u7528 7 \u4f4d\u4e8c\u8fdb\u5236\u6570\uff08\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\u5982\u56fe 3-6 \u6240\u793a\uff0cASCII \u7801\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

    \u56fe 3-6 \u00a0 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\u300cEASCII\u300d\u5b57\u7b26\u96c6\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\u6bd4\u5982\u6c49\u5b57\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\u7f55\u89c1\u5b57\u548c\u7e41\u4f53\u5b57\u3002\u300cGBK\u300d\u5b57\u7b26\u96c6\u662f\u5728 GB2312 \u7684\u57fa\u7840\u4e0a\u6269\u5c55\u5f97\u5230\u7684\uff0c\u5b83\u5171\u6536\u5f55\u4e86 21886 \u4e2a\u6c49\u5b57\u3002\u5728 GBK \u7684\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\u6280\u672f\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\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u540c\u4e00\u79cd\u8bed\u8a00\u5b58\u5728\u591a\u79cd\u5b57\u7b26\u96c6\u6807\u51c6\uff0c\u5982\u679c\u4e24\u53f0\u8ba1\u7b97\u673a\u4f7f\u7528\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\u7814\u7a76\u4eba\u5458\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\u4e2d\u6587\u540d\u79f0\u4e3a\u201c\u7edf\u4e00\u7801\u201d\uff0c\u7406\u8bba\u4e0a\u80fd\u5bb9\u7eb3 100 \u591a\u4e07\u4e2a\u5b57\u7b26\u3002\u5b83\u81f4\u529b\u4e8e\u5c06\u5168\u7403\u8303\u56f4\u5185\u7684\u5b57\u7b26\u7eb3\u5165\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\u81f3 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\u751a\u81f3\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\u7528 3 \u5b57\u8282\u751a\u81f3 4 \u5b57\u8282\u3002

    Unicode \u662f\u4e00\u79cd\u901a\u7528\u5b57\u7b26\u96c6\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\u4e00\u4e2a\u6587\u672c\u4e2d\u65f6\uff0c\u7cfb\u7edf\u5982\u4f55\u89e3\u6790\u5b57\u7b26\uff1f\u4f8b\u5982\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\u56fe 3-7 \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 \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\u8fd9\u4e2a\u77ed\u8bed\u7684\u5185\u5bb9\u4e86\u3002

    \u56fe 3-7 \u00a0 Unicode \u7f16\u7801\u793a\u4f8b

    \u7136\u800c ASCII \u7801\u5df2\u7ecf\u5411\u6211\u4eec\u8bc1\u660e\uff0c\u7f16\u7801\u82f1\u6587\u53ea\u9700 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\u7684\u4e24\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\u5ea6\u7684\u7f16\u7801\uff0c\u4f7f\u7528 1 \u5230 4 \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 1 \u5b57\u8282\uff0c\u62c9\u4e01\u5b57\u6bcd\u548c\u5e0c\u814a\u5b57\u6bcd\u9700\u8981 2 \u5b57\u8282\uff0c\u5e38\u7528\u7684\u4e2d\u6587\u5b57\u7b26\u9700\u8981 3 \u5b57\u8282\uff0c\u5176\u4ed6\u7684\u4e00\u4e9b\u751f\u50fb\u5b57\u7b26\u9700\u8981 4 \u5b57\u8282\u3002

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

    • \u5bf9\u4e8e\u957f\u5ea6\u4e3a 1 \u5b57\u8282\u7684\u5b57\u7b26\uff0c\u5c06\u6700\u9ad8\u4f4d\u8bbe\u7f6e\u4e3a \\(0\\) \uff0c\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\\) \uff0c\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

    \u56fe 3-8 \u5c55\u793a\u4e86\u201cHello\u7b97\u6cd5\u201d\u5bf9\u5e94\u7684 UTF-8 \u7f16\u7801\u3002\u89c2\u5bdf\u53d1\u73b0\uff0c\u7531\u4e8e\u6700\u9ad8 \\(n\\) \u4f4d\u90fd\u8bbe\u7f6e\u4e3a \\(1\\) \uff0c\u56e0\u6b64\u7cfb\u7edf\u53ef\u4ee5\u901a\u8fc7\u8bfb\u53d6\u6700\u9ad8\u4f4d \\(1\\) \u7684\u4e2a\u6570\u6765\u89e3\u6790\u51fa\u5b57\u7b26\u7684\u957f\u5ea6\u4e3a \\(n\\) \u3002

    \u4f46\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\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\u5224\u65ad\u51fa\u5f02\u5e38\u3002

    \u4e4b\u6240\u4ee5\u5c06 \\(10\\) \u5f53\u4f5c\u6821\u9a8c\u7b26\uff0c\u662f\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\u4e2a\u7ed3\u8bba\u53ef\u4ee5\u7528\u53cd\u8bc1\u6cd5\u6765\u8bc1\u660e\uff1a\u5047\u8bbe\u4e00\u4e2a\u5b57\u7b26\u7684\u6700\u9ad8\u4e24\u4f4d\u662f \\(10\\) \uff0c\u8bf4\u660e\u8be5\u5b57\u7b26\u7684\u957f\u5ea6\u4e3a \\(1\\) \uff0c\u5bf9\u5e94 ASCII \u7801\u3002\u800c ASCII \u7801\u7684\u6700\u9ad8\u4f4d\u5e94\u8be5\u662f \\(0\\) \uff0c\u4e0e\u5047\u8bbe\u77db\u76fe\u3002

    \u56fe 3-8 \u00a0 UTF-8 \u7f16\u7801\u793a\u4f8b

    \u9664\u4e86 UTF-8 \u4e4b\u5916\uff0c\u5e38\u89c1\u7684\u7f16\u7801\u65b9\u5f0f\u8fd8\u5305\u62ec\u4ee5\u4e0b\u4e24\u79cd\u3002

    • UTF-16 \u7f16\u7801\uff1a\u4f7f\u7528 2 \u6216 4 \u5b57\u8282\u6765\u8868\u793a\u4e00\u4e2a\u5b57\u7b26\u3002\u6240\u6709\u7684 ASCII \u5b57\u7b26\u548c\u5e38\u7528\u7684\u975e\u82f1\u6587\u5b57\u7b26\uff0c\u90fd\u7528 2 \u5b57\u8282\u8868\u793a\uff1b\u5c11\u6570\u5b57\u7b26\u9700\u8981\u7528\u5230 4 \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 \u5b57\u8282\u3002\u8fd9\u610f\u5473\u7740 UTF-32 \u6bd4 UTF-8 \u548c UTF-16 \u66f4\u5360\u7528\u7a7a\u95f4\uff0c\u7279\u522b\u662f\u5bf9\u4e8e ASCII \u5b57\u7b26\u5360\u6bd4\u8f83\u9ad8\u7684\u6587\u672c\u3002

    \u4ece\u5b58\u50a8\u7a7a\u95f4\u5360\u7528\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 \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\u4ec5\u9700 2 \u5b57\u8282\uff0c\u800c UTF-8 \u53ef\u80fd\u9700\u8981 3 \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\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\u7f16\u7801\u3002\u5728\u7b49\u957f\u7f16\u7801\u4e0b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5b57\u7b26\u4e32\u770b\u4f5c\u6570\u7ec4\u6765\u5904\u7406\uff0c\u8fd9\u79cd\u505a\u6cd5\u5177\u6709\u4ee5\u4e0b\u4f18\u70b9\u3002

    • \u968f\u673a\u8bbf\u95ee\uff1aUTF-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\u60f3\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\uff1a\u4e0e\u968f\u673a\u8bbf\u95ee\u7c7b\u4f3c\uff0c\u8ba1\u7b97 UTF-16 \u7f16\u7801\u7684\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\uff1a\u5728 UTF-16 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u4e0a\uff0c\u5f88\u591a\u5b57\u7b26\u4e32\u64cd\u4f5c\uff08\u5982\u5206\u5272\u3001\u8fde\u63a5\u3001\u63d2\u5165\u3001\u5220\u9664\u7b49\uff09\u66f4\u5bb9\u6613\u8fdb\u884c\u3002\u5728 UTF-8 \u7f16\u7801\u7684\u5b57\u7b26\u4e32\u4e0a\uff0c\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

    \u5b9e\u9645\u4e0a\uff0c\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\u8bb8\u591a\u56e0\u7d20\u3002

    • 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 1995 \u5e74 Netscape \u516c\u53f8\u9996\u6b21\u63a8\u51fa JavaScript \u8bed\u8a00\u65f6\uff0cUnicode \u8fd8\u5904\u4e8e\u53d1\u5c55\u65e9\u671f\uff0c\u90a3\u65f6\u5019\u4f7f\u7528 16 \u4f4d\u7684\u7f16\u7801\u5c31\u8db3\u4ee5\u8868\u793a\u6240\u6709\u7684 Unicode \u5b57\u7b26\u4e86\u3002
    • C# \u4f7f\u7528 UTF-16 \u7f16\u7801\uff0c\u4e3b\u8981\u662f\u56e0\u4e3a .NET \u5e73\u53f0\u662f\u7531 Microsoft \u8bbe\u8ba1\u7684\uff0c\u800c Microsoft \u7684\u5f88\u591a\u6280\u672f\uff08\u5305\u62ec Windows \u64cd\u4f5c\u7cfb\u7edf\uff09\u90fd\u5e7f\u6cdb\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\u4ece\u800c\u4e27\u5931\u4e86\u7b49\u957f\u7f16\u7801\u7684\u4f18\u52bf\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u5904\u7406\u4ee3\u7406\u5bf9\u9700\u8981\u989d\u5916\u589e\u52a0\u4ee3\u7801\uff0c\u8fd9\u63d0\u9ad8\u4e86\u7f16\u7a0b\u7684\u590d\u6742\u6027\u548c\u8c03\u8bd5\u96be\u5ea6\u3002

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

    • Python \u4e2d\u7684 str \u4f7f\u7528 Unicode \u7f16\u7801\uff0c\u5e76\u91c7\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\u82e5\u5b57\u7b26\u4e32\u4e2d\u5168\u90e8\u662f ASCII \u5b57\u7b26\uff0c\u5219\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 1 \u5b57\u8282\uff1b\u5982\u679c\u6709\u5b57\u7b26\u8d85\u51fa\u4e86 ASCII \u8303\u56f4\uff0c\u4f46\u5168\u90e8\u5728\u57fa\u672c\u591a\u8bed\u8a00\u5e73\u9762\uff08BMP\uff09\u5185\uff0c\u5219\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 2 \u5b57\u8282\uff1b\u5982\u679c\u6709\u8d85\u51fa BMP \u7684\u5b57\u7b26\uff0c\u5219\u6bcf\u4e2a\u5b57\u7b26\u5360\u7528 4 \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\u4e0d\u540c\u7684\u95ee\u9898\u3002\u5728\u6587\u4ef6\u5b58\u50a8\u6216\u7f51\u7edc\u4f20\u8f93\u4e2d\uff0c\u6211\u4eec\u901a\u5e38\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":"

    \u5e38\u89c1\u7684\u6570\u636e\u7ed3\u6784\u5305\u62ec\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\uff0c\u5b83\u4eec\u53ef\u4ee5\u4ece\u201c\u903b\u8f91\u7ed3\u6784\u201d\u548c\u201c\u7269\u7406\u7ed3\u6784\u201d\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":"

    \u903b\u8f91\u7ed3\u6784\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\u4e00\u5b9a\u987a\u5e8f\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\u201c\u7956\u5148\u201d\u4e0e\u201c\u540e\u4ee3\u201d\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

    \u5982\u56fe 3-1 \u6240\u793a\uff0c\u903b\u8f91\u7ed3\u6784\u53ef\u5206\u4e3a\u201c\u7ebf\u6027\u201d\u548c\u201c\u975e\u7ebf\u6027\u201d\u4e24\u5927\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\uff0c\u5143\u7d20\u4e4b\u95f4\u662f\u4e00\u5bf9\u4e00\u7684\u987a\u5e8f\u5173\u7cfb\u3002
    • \u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff1a\u6811\u3001\u5806\u3001\u56fe\u3001\u54c8\u5e0c\u8868\u3002

    \u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u8fdb\u4e00\u6b65\u5212\u5206\u4e3a\u6811\u5f62\u7ed3\u6784\u548c\u7f51\u72b6\u7ed3\u6784\u3002

    • \u6811\u5f62\u7ed3\u6784\uff1a\u6811\u3001\u5806\u3001\u54c8\u5e0c\u8868\uff0c\u5143\u7d20\u4e4b\u95f4\u662f\u4e00\u5bf9\u591a\u7684\u5173\u7cfb\u3002
    • \u7f51\u72b6\u7ed3\u6784\uff1a\u56fe\uff0c\u5143\u7d20\u4e4b\u95f4\u662f\u591a\u5bf9\u591a\u7684\u5173\u7cfb\u3002

    \u56fe 3-1 \u00a0 \u7ebf\u6027\u6570\u636e\u7ed3\u6784\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\u5206\u6563","text":"

    \u5f53\u7b97\u6cd5\u7a0b\u5e8f\u8fd0\u884c\u65f6\uff0c\u6b63\u5728\u5904\u7406\u7684\u6570\u636e\u4e3b\u8981\u5b58\u50a8\u5728\u5185\u5b58\u4e2d\u3002\u56fe 3-2 \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\u4e00\u5b9a\u5927\u5c0f\u7684\u6570\u636e\u3002

    \u7cfb\u7edf\u901a\u8fc7\u5185\u5b58\u5730\u5740\u6765\u8bbf\u95ee\u76ee\u6807\u4f4d\u7f6e\u7684\u6570\u636e\u3002\u5982\u56fe 3-2 \u6240\u793a\uff0c\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

    \u56fe 3-2 \u00a0 \u5185\u5b58\u6761\u3001\u5185\u5b58\u7a7a\u95f4\u3001\u5185\u5b58\u5730\u5740

    Tip

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u5c06\u5185\u5b58\u6bd4\u4f5c Excel \u8868\u683c\u662f\u4e00\u4e2a\u7b80\u5316\u7684\u7c7b\u6bd4\uff0c\u5b9e\u9645\u5185\u5b58\u7684\u5de5\u4f5c\u673a\u5236\u6bd4\u8f83\u590d\u6742\uff0c\u6d89\u53ca\u5730\u5740\u7a7a\u95f4\u3001\u5185\u5b58\u7ba1\u7406\u3001\u7f13\u5b58\u673a\u5236\u3001\u865a\u62df\u5185\u5b58\u548c\u7269\u7406\u5185\u5b58\u7b49\u6982\u5ff5\u3002

    \u5185\u5b58\u662f\u6240\u6709\u7a0b\u5e8f\u7684\u5171\u4eab\u8d44\u6e90\uff0c\u5f53\u67d0\u5757\u5185\u5b58\u88ab\u67d0\u4e2a\u7a0b\u5e8f\u5360\u7528\u65f6\uff0c\u5219\u65e0\u6cd5\u88ab\u5176\u4ed6\u7a0b\u5e8f\u540c\u65f6\u4f7f\u7528\u4e86\u3002\u56e0\u6b64\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\u6bd4\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\u7f3a\u5c11\u8fde\u7eed\u5927\u5757\u7684\u5185\u5b58\u7a7a\u95f4\uff0c\u90a3\u4e48\u6240\u9009\u7528\u7684\u6570\u636e\u7ed3\u6784\u5fc5\u987b\u80fd\u591f\u5b58\u50a8\u5728\u5206\u6563\u7684\u5185\u5b58\u7a7a\u95f4\u5185\u3002

    \u5982\u56fe 3-3 \u6240\u793a\uff0c\u7269\u7406\u7ed3\u6784\u53cd\u6620\u4e86\u6570\u636e\u5728\u8ba1\u7b97\u673a\u5185\u5b58\u4e2d\u7684\u5b58\u50a8\u65b9\u5f0f\uff0c\u53ef\u5206\u4e3a\u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\uff08\u6570\u7ec4\uff09\u548c\u5206\u6563\u7a7a\u95f4\u5b58\u50a8\uff08\u94fe\u8868\uff09\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\u4e24\u79cd\u7269\u7406\u7ed3\u6784\u5728\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u65b9\u9762\u5448\u73b0\u51fa\u4e92\u8865\u7684\u7279\u70b9\u3002

    \u56fe 3-3 \u00a0 \u8fde\u7eed\u7a7a\u95f4\u5b58\u50a8\u4e0e\u5206\u6563\u7a7a\u95f4\u5b58\u50a8

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\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\u3002
    • \u57fa\u4e8e\u94fe\u8868\u53ef\u5b9e\u73b0\uff1a\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u7b49\u3002

    \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u4e5f\u79f0\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\u4e5f\u79f0\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\u679c\u4f60\u611f\u89c9\u7269\u7406\u7ed3\u6784\u7406\u89e3\u8d77\u6765\u6709\u56f0\u96be\uff0c\u5efa\u8bae\u5148\u9605\u8bfb\u4e0b\u4e00\u7ae0\uff0c\u7136\u540e\u518d\u56de\u987e\u672c\u8282\u5185\u5bb9\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 * \u7b26\u53f7\u7684\u662f\u9009\u8bfb\u7ae0\u8282\u3002\u5982\u679c\u4f60\u65f6\u95f4\u6709\u9650\u6216\u611f\u5230\u7406\u89e3\u56f0\u96be\uff0c\u53ef\u4ee5\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":"

    \u5728\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\uff0c\u4f8b\u5982 byte \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\u539f\u7801\u3001\u53cd\u7801\u3001\u8865\u7801\u7684\u76f8\u5173\u77e5\u8bc6\u3002

    \u9996\u5148\u9700\u8981\u6307\u51fa\uff0c\u6570\u5b57\u662f\u4ee5\u201c\u8865\u7801\u201d\u7684\u5f62\u5f0f\u5b58\u50a8\u5728\u8ba1\u7b97\u673a\u4e2d\u7684\u3002\u5728\u5206\u6790\u8fd9\u6837\u505a\u7684\u539f\u56e0\u4e4b\u524d\uff0c\u9996\u5148\u7ed9\u51fa\u4e09\u8005\u7684\u5b9a\u4e49\u3002

    • \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

    \u56fe 3-4 \u5c55\u793a\u4e86\u539f\u7801\u3001\u53cd\u7801\u548c\u8865\u7801\u4e4b\u95f4\u7684\u8f6c\u6362\u65b9\u6cd5\u3002

    \u56fe 3-4 \u00a0 \u539f\u7801\u3001\u53cd\u7801\u4e0e\u8865\u7801\u4e4b\u95f4\u7684\u76f8\u4e92\u8f6c\u6362

    \u300c\u539f\u7801 sign-magnitude\u300d\u867d\u7136\u6700\u76f4\u89c2\uff0c\u4f46\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\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 & \\rightarrow 0000 \\; 0001 + 1000 \\; 0010 \\newline & = 1000 \\; 0011 \\newline & \\rightarrow -3 \\end{aligned} \\]

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

    \\[ \\begin{aligned} & 1 + (-2) \\newline & \\rightarrow 0000 \\; 0001 \\; \\text{(\u539f\u7801)} + 1000 \\; 0010 \\; \\text{(\u539f\u7801)} \\newline & = 0000 \\; 0001 \\; \\text{(\u53cd\u7801)} + 1111 \\; 1101 \\; \\text{(\u53cd\u7801)} \\newline & = 1111 \\; 1110 \\; \\text{(\u53cd\u7801)} \\newline & = 1000 \\; 0001 \\; \\text{(\u539f\u7801)} \\newline & \\rightarrow -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\u4e24\u4e2a\u4e0d\u540c\u7684\u4e8c\u8fdb\u5236\u7f16\u7801\uff0c\u8fd9\u53ef\u80fd\u4f1a\u5e26\u6765\u6b67\u4e49\u3002\u6bd4\u5982\u5728\u6761\u4ef6\u5224\u65ad\u4e2d\uff0c\u5982\u679c\u6ca1\u6709\u533a\u5206\u6b63\u96f6\u548c\u8d1f\u96f6\uff0c\u5219\u53ef\u80fd\u4f1a\u5bfc\u81f4\u5224\u65ad\u7ed3\u679c\u51fa\u9519\u3002\u800c\u5982\u679c\u6211\u4eec\u60f3\u5904\u7406\u6b63\u96f6\u548c\u8d1f\u96f6\u6b67\u4e49\uff0c\u5219\u9700\u8981\u5f15\u5165\u989d\u5916\u7684\u5224\u65ad\u64cd\u4f5c\uff0c\u8fd9\u53ef\u80fd\u4f1a\u964d\u4f4e\u8ba1\u7b97\u673a\u7684\u8fd0\u7b97\u6548\u7387\u3002

    \\[ \\begin{aligned} +0 & \\rightarrow 0000 \\; 0000 \\newline -0 & \\rightarrow 1000 \\; 0000 \\end{aligned} \\]

    \u4e0e\u539f\u7801\u4e00\u6837\uff0c\u53cd\u7801\u4e5f\u5b58\u5728\u6b63\u8d1f\u96f6\u6b67\u4e49\u95ee\u9898\uff0c\u56e0\u6b64\u8ba1\u7b97\u673a\u8fdb\u4e00\u6b65\u5f15\u5165\u4e86\u300c\u8865\u7801 2's complement\u300d\u3002\u6211\u4eec\u5148\u6765\u89c2\u5bdf\u4e00\u4e0b\u8d1f\u96f6\u7684\u539f\u7801\u3001\u53cd\u7801\u3001\u8865\u7801\u7684\u8f6c\u6362\u8fc7\u7a0b\uff1a

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

    \u5728\u8d1f\u96f6\u7684\u53cd\u7801\u57fa\u7840\u4e0a\u52a0 \\(1\\) \u4f1a\u4ea7\u751f\u8fdb\u4f4d\uff0c\u4f46 byte \u7c7b\u578b\u7684\u957f\u5ea6\u53ea\u6709 8 \u4f4d\uff0c\u56e0\u6b64\u6ea2\u51fa\u5230\u7b2c 9 \u4f4d\u7684 \\(1\\) \u4f1a\u88ab\u820d\u5f03\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u8d1f\u96f6\u7684\u8865\u7801\u4e3a \\(0000 \\; 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\u6b63\u8d1f\u96f6\u6b67\u4e49\u4ece\u800c\u5f97\u5230\u89e3\u51b3\u3002

    \u8fd8\u5269\u6700\u540e\u4e00\u4e2a\u7591\u60d1\uff1abyte \u7c7b\u578b\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\u53ef\u4ee5\u4e92\u76f8\u8f6c\u6362\u3002

    \u7136\u800c\uff0c\u8865\u7801 \\(1000 \\; 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 \\; 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 \\; 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 & \\rightarrow 1111 \\; 1111 \\; \\text{(\u539f\u7801)} + 1000 \\; 0001 \\; \\text{(\u539f\u7801)} \\newline & = 1000 \\; 0000 \\; \\text{(\u53cd\u7801)} + 1111 \\; 1110 \\; \\text{(\u53cd\u7801)} \\newline & = 1000 \\; 0001 \\; \\text{(\u8865\u7801)} + 1111 \\; 1111 \\; \\text{(\u8865\u7801)} \\newline & = 1000 \\; 0000 \\; \\text{(\u8865\u7801)} \\newline & \\rightarrow -128 \\end{aligned} \\]

    \u4f60\u53ef\u80fd\u5df2\u7ecf\u53d1\u73b0\u4e86\uff0c\u4e0a\u8ff0\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\u8fd0\u7b97\u901f\u5ea6\u66f4\u5feb\u3002

    \u8bf7\u6ce8\u610f\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\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\u987b\u7279\u522b\u5904\u7406\u6b63\u8d1f\u96f6\u7684\u6b67\u4e49\u95ee\u9898\u3002\u8fd9\u5927\u5927\u7b80\u5316\u4e86\u786c\u4ef6\u8bbe\u8ba1\uff0c\u63d0\u9ad8\u4e86\u8fd0\u7b97\u6548\u7387\u3002

    \u8865\u7801\u7684\u8bbe\u8ba1\u975e\u5e38\u7cbe\u5999\uff0c\u56e0\u7bc7\u5e45\u5173\u7cfb\u6211\u4eec\u5c31\u5148\u4ecb\u7ecd\u5230\u8fd9\u91cc\uff0c\u5efa\u8bae\u6709\u5174\u8da3\u7684\u8bfb\u8005\u8fdb\u4e00\u6b65\u6df1\u5165\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 \u5b57\u8282 \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\u8bb0\u4e00\u4e2a 32 \u6bd4\u7279\u957f\u5ea6\u7684\u4e8c\u8fdb\u5236\u6570\u4e3a\uff1a

    \\[ b_{31} b_{30} b_{29} \\ldots b_2 b_1 b_0 \\]

    \u6839\u636e IEEE 754 \u6807\u51c6\uff0c32-bit \u957f\u5ea6\u7684 float \u7531\u4ee5\u4e0b\u4e09\u4e2a\u90e8\u5206\u6784\u6210\u3002

    • \u7b26\u53f7\u4f4d \\(\\mathrm{S}\\) \uff1a\u5360 1 \u4f4d \uff0c\u5bf9\u5e94 \\(b_{31}\\) \u3002
    • \u6307\u6570\u4f4d \\(\\mathrm{E}\\) \uff1a\u5360 8 \u4f4d \uff0c\u5bf9\u5e94 \\(b_{30} b_{29} \\ldots b_{23}\\) \u3002
    • \u5206\u6570\u4f4d \\(\\mathrm{N}\\) \uff1a\u5360 23 \u4f4d \uff0c\u5bf9\u5e94 \\(b_{22} b_{21} \\ldots b_0\\) \u3002

    \u4e8c\u8fdb\u5236\u6570 float \u5bf9\u5e94\u503c\u7684\u8ba1\u7b97\u65b9\u6cd5\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\uff1a

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

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

    \\[ \\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} \\]

    \u56fe 3-5 \u00a0 IEEE 754 \u6807\u51c6\u4e0b\u7684 float \u7684\u8ba1\u7b97\u793a\u4f8b

    \u89c2\u5bdf\u56fe 3-5 \uff0c\u7ed9\u5b9a\u4e00\u4e2a\u793a\u4f8b\u6570\u636e \\(\\mathrm{S} = 0\\) \uff0c \\(\\mathrm{E} = 124\\) \uff0c\\(\\mathrm{N} = 2^{-2} + 2^{-3} = 0.375\\) \uff0c\u5219\u6709\uff1a

    \\[ \\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 \u6bd4\u7279\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

    \u5982\u8868 3-2 \u6240\u793a\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

    \u8868 3-2 \u00a0 \u6307\u6570\u4f4d\u542b\u4e49

    \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}\\)

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u6b21\u6b63\u89c4\u6570\u663e\u8457\u63d0\u5347\u4e86\u6d6e\u70b9\u6570\u7684\u7cbe\u5ea6\u3002\u6700\u5c0f\u6b63\u6b63\u89c4\u6570\u4e3a \\(2^{-126}\\) \uff0c\u6700\u5c0f\u6b63\u6b21\u6b63\u89c4\u6570\u4e3a \\(2^{-126} \\times 2^{-23}\\) \u3002

    \u53cc\u7cbe\u5ea6 double \u4e5f\u91c7\u7528\u7c7b\u4f3c\u4e8e float \u7684\u8868\u793a\u65b9\u6cd5\uff0c\u5728\u6b64\u4e0d\u505a\u8d58\u8ff0\u3002

    "},{"location":"chapter_data_structure/summary/","title":"3.5 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_data_structure/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","text":"
    • \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\u6570\u636e\u7ed3\u6784\u548c\u975e\u7ebf\u6027\u6570\u636e\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\u5206\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
    • \u8ba1\u7b97\u673a\u4e2d\u7684\u57fa\u672c\u6570\u636e\u7c7b\u578b\u5305\u62ec\u6574\u6570 byte\u3001short\u3001int\u3001long \uff0c\u6d6e\u70b9\u6570 float\u3001double \uff0c\u5b57\u7b26 char \u548c\u5e03\u5c14 bool \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\u53ef\u4ee5\u76f8\u4e92\u8f6c\u6362\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\u56e0\u6b64\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\u4e0a\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 \u5360\u7528\u7684\u7a7a\u95f4\u6bd4 UTF-8 \u66f4\u5c0f\u3002Java \u548c C# \u7b49\u7f16\u7a0b\u8bed\u8a00\u9ed8\u8ba4\u4f7f\u7528 UTF-16 \u7f16\u7801\u3002
    "},{"location":"chapter_data_structure/summary/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u94fe\u5f0f\u5730\u5740\u201d\uff08\u540e\u7eed\u201c\u54c8\u5e0c\u51b2\u7a81\u201d\u7ae0\u8282\u4f1a\u8bb2\uff09\uff1a\u6570\u7ec4\u4e2d\u6bcf\u4e2a\u6876\u6307\u5411\u4e00\u4e2a\u94fe\u8868\uff0c\u5f53\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

    \u4ece\u5b58\u50a8\u7684\u89d2\u5ea6\u6765\u770b\uff0c\u54c8\u5e0c\u8868\u7684\u5e95\u5c42\u662f\u6570\u7ec4\uff0c\u5176\u4e2d\u6bcf\u4e00\u4e2a\u6876\u69fd\u4f4d\u53ef\u80fd\u5305\u542b\u4e00\u4e2a\u503c\uff0c\u4e5f\u53ef\u80fd\u5305\u542b\u4e00\u4e2a\u94fe\u8868\u6216\u4e00\u68f5\u6811\u3002\u56e0\u6b64\uff0c\u54c8\u5e0c\u8868\u53ef\u80fd\u540c\u65f6\u5305\u542b\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff08\u6570\u7ec4\u3001\u94fe\u8868\uff09\u548c\u975e\u7ebf\u6027\u6570\u636e\u7ed3\u6784\uff08\u6811\uff09\u3002

    Q\uff1achar \u7c7b\u578b\u7684\u957f\u5ea6\u662f 1 \u5b57\u8282\u5417\uff1f

    char \u7c7b\u578b\u7684\u957f\u5ea6\u7531\u7f16\u7a0b\u8bed\u8a00\u91c7\u7528\u7684\u7f16\u7801\u65b9\u6cd5\u51b3\u5b9a\u3002\u4f8b\u5982\uff0cJava\u3001JavaScript\u3001TypeScript\u3001C# \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 \u5b57\u8282\u3002

    Q\uff1a\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6570\u636e\u7ed3\u6784\u4e5f\u79f0\u201c\u9759\u6001\u6570\u636e\u7ed3\u6784\u201d \u662f\u5426\u6709\u6b67\u4e49\uff1f\u6808\u4e5f\u53ef\u4ee5\u8fdb\u884c\u51fa\u6808\u548c\u5165\u6808\u7b49\u64cd\u4f5c\uff0c\u8fd9\u4e9b\u64cd\u4f5c\u90fd\u662f\u201c\u52a8\u6001\u201d\u7684\u3002

    \u6808\u786e\u5b9e\u53ef\u4ee5\u5b9e\u73b0\u52a8\u6001\u7684\u6570\u636e\u64cd\u4f5c\uff0c\u4f46\u6570\u636e\u7ed3\u6784\u4ecd\u7136\u662f\u201c\u9759\u6001\u201d\uff08\u957f\u5ea6\u4e0d\u53ef\u53d8\uff09\u7684\u3002\u5c3d\u7ba1\u57fa\u4e8e\u6570\u7ec4\u7684\u6570\u636e\u7ed3\u6784\u53ef\u4ee5\u52a8\u6001\u5730\u6dfb\u52a0\u6216\u5220\u9664\u5143\u7d20\uff0c\u4f46\u5b83\u4eec\u7684\u5bb9\u91cf\u662f\u56fa\u5b9a\u7684\u3002\u5982\u679c\u6570\u636e\u91cf\u8d85\u51fa\u4e86\u9884\u5206\u914d\u7684\u5927\u5c0f\uff0c\u5c31\u9700\u8981\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u66f4\u5927\u7684\u6570\u7ec4\uff0c\u5e76\u5c06\u65e7\u6570\u7ec4\u7684\u5185\u5bb9\u590d\u5236\u5230\u65b0\u6570\u7ec4\u4e2d\u3002

    Q\uff1a\u5728\u6784\u5efa\u6808\uff08\u961f\u5217\uff09\u7684\u65f6\u5019\uff0c\u672a\u6307\u5b9a\u5b83\u7684\u5927\u5c0f\uff0c\u4e3a\u4ec0\u4e48\u5b83\u4eec\u662f\u201c\u9759\u6001\u6570\u636e\u7ed3\u6784\u201d\u5462\uff1f

    \u5728\u9ad8\u7ea7\u7f16\u7a0b\u8bed\u8a00\u4e2d\uff0c\u6211\u4eec\u65e0\u987b\u4eba\u5de5\u6307\u5b9a\u6808\uff08\u961f\u5217\uff09\u7684\u521d\u59cb\u5bb9\u91cf\uff0c\u8fd9\u4e2a\u5de5\u4f5c\u7531\u7c7b\u5185\u90e8\u81ea\u52a8\u5b8c\u6210\u3002\u4f8b\u5982\uff0cJava \u7684 ArrayList \u7684\u521d\u59cb\u5bb9\u91cf\u901a\u5e38\u4e3a 10\u3002\u53e6\u5916\uff0c\u6269\u5bb9\u64cd\u4f5c\u4e5f\u662f\u81ea\u52a8\u5b9e\u73b0\u7684\u3002\u8be6\u89c1\u540e\u7eed\u7684\u201c\u5217\u8868\u201d\u7ae0\u8282\u3002

    "},{"location":"chapter_divide_and_conquer/","title":"\u7b2c 12 \u7ae0 \u00a0 \u5206\u6cbb","text":"

    Abstract

    \u96be\u9898\u88ab\u9010\u5c42\u62c6\u89e3\uff0c\u6bcf\u4e00\u6b21\u7684\u62c6\u89e3\u90fd\u4f7f\u5b83\u53d8\u5f97\u66f4\u4e3a\u7b80\u5355\u3002

    \u5206\u800c\u6cbb\u4e4b\u63ed\u793a\u4e86\u4e00\u4e2a\u91cd\u8981\u7684\u4e8b\u5b9e\uff1a\u4ece\u7b80\u5355\u505a\u8d77\uff0c\u4e00\u5207\u90fd\u4e0d\u518d\u590d\u6742\u3002

    "},{"location":"chapter_divide_and_conquer/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 12.1 \u00a0 \u5206\u6cbb\u7b97\u6cd5
    • 12.2 \u00a0 \u5206\u6cbb\u641c\u7d22\u7b56\u7565
    • 12.3 \u00a0 \u6784\u5efa\u6811\u95ee\u9898
    • 12.4 \u00a0 \u6c49\u8bfa\u5854\u95ee\u9898
    • 12.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_divide_and_conquer/binary_search_recur/","title":"12.2 \u00a0 \u5206\u6cbb\u641c\u7d22\u7b56\u7565","text":"

    \u6211\u4eec\u5df2\u7ecf\u5b66\u8fc7\uff0c\u641c\u7d22\u7b97\u6cd5\u5206\u4e3a\u4e24\u5927\u7c7b\u3002

    • \u66b4\u529b\u641c\u7d22\uff1a\u5b83\u901a\u8fc7\u904d\u5386\u6570\u636e\u7ed3\u6784\u5b9e\u73b0\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002
    • \u81ea\u9002\u5e94\u641c\u7d22\uff1a\u5b83\u5229\u7528\u7279\u6709\u7684\u6570\u636e\u7ec4\u7ec7\u5f62\u5f0f\u6216\u5148\u9a8c\u4fe1\u606f\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u8fbe\u5230 \\(O(\\log n)\\) \u751a\u81f3 \\(O(1)\\) \u3002

    \u5b9e\u9645\u4e0a\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u7684\u641c\u7d22\u7b97\u6cd5\u901a\u5e38\u662f\u57fa\u4e8e\u5206\u6cbb\u7b56\u7565\u5b9e\u73b0\u7684\uff0c\u4f8b\u5982\u4e8c\u5206\u67e5\u627e\u548c\u6811\u3002

    • \u4e8c\u5206\u67e5\u627e\u7684\u6bcf\u4e00\u6b65\u90fd\u5c06\u95ee\u9898\uff08\u5728\u6570\u7ec4\u4e2d\u641c\u7d22\u76ee\u6807\u5143\u7d20\uff09\u5206\u89e3\u4e3a\u4e00\u4e2a\u5c0f\u95ee\u9898\uff08\u5728\u6570\u7ec4\u7684\u4e00\u534a\u4e2d\u641c\u7d22\u76ee\u6807\u5143\u7d20\uff09\uff0c\u8fd9\u4e2a\u8fc7\u7a0b\u4e00\u76f4\u6301\u7eed\u5230\u6570\u7ec4\u4e3a\u7a7a\u6216\u627e\u5230\u76ee\u6807\u5143\u7d20\u4e3a\u6b62\u3002
    • \u6811\u662f\u5206\u6cbb\u601d\u60f3\u7684\u4ee3\u8868\uff0c\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u3001AVL \u6811\u3001\u5806\u7b49\u6570\u636e\u7ed3\u6784\u4e2d\uff0c\u5404\u79cd\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u7686\u4e3a \\(O(\\log n)\\) \u3002

    \u4e8c\u5206\u67e5\u627e\u7684\u5206\u6cbb\u7b56\u7565\u5982\u4e0b\u6240\u793a\u3002

    • \u95ee\u9898\u53ef\u4ee5\u5206\u89e3\uff1a\u4e8c\u5206\u67e5\u627e\u9012\u5f52\u5730\u5c06\u539f\u95ee\u9898\uff08\u5728\u6570\u7ec4\u4e2d\u8fdb\u884c\u67e5\u627e\uff09\u5206\u89e3\u4e3a\u5b50\u95ee\u9898\uff08\u5728\u6570\u7ec4\u7684\u4e00\u534a\u4e2d\u8fdb\u884c\u67e5\u627e\uff09\uff0c\u8fd9\u662f\u901a\u8fc7\u6bd4\u8f83\u4e2d\u95f4\u5143\u7d20\u548c\u76ee\u6807\u5143\u7d20\u6765\u5b9e\u73b0\u7684\u3002
    • \u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff1a\u5728\u4e8c\u5206\u67e5\u627e\u4e2d\uff0c\u6bcf\u8f6e\u53ea\u5904\u7406\u4e00\u4e2a\u5b50\u95ee\u9898\uff0c\u5b83\u4e0d\u53d7\u5176\u4ed6\u5b50\u95ee\u9898\u7684\u5f71\u54cd\u3002
    • \u5b50\u95ee\u9898\u7684\u89e3\u65e0\u987b\u5408\u5e76\uff1a\u4e8c\u5206\u67e5\u627e\u65e8\u5728\u67e5\u627e\u4e00\u4e2a\u7279\u5b9a\u5143\u7d20\uff0c\u56e0\u6b64\u4e0d\u9700\u8981\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u8fdb\u884c\u5408\u5e76\u3002\u5f53\u5b50\u95ee\u9898\u5f97\u5230\u89e3\u51b3\u65f6\uff0c\u539f\u95ee\u9898\u4e5f\u4f1a\u540c\u65f6\u5f97\u5230\u89e3\u51b3\u3002

    \u5206\u6cbb\u80fd\u591f\u63d0\u5347\u641c\u7d22\u6548\u7387\uff0c\u672c\u8d28\u4e0a\u662f\u56e0\u4e3a\u66b4\u529b\u641c\u7d22\u6bcf\u8f6e\u53ea\u80fd\u6392\u9664\u4e00\u4e2a\u9009\u9879\uff0c\u800c\u5206\u6cbb\u641c\u7d22\u6bcf\u8f6e\u53ef\u4ee5\u6392\u9664\u4e00\u534a\u9009\u9879\u3002

    "},{"location":"chapter_divide_and_conquer/binary_search_recur/#1","title":"1. \u00a0 \u57fa\u4e8e\u5206\u6cbb\u5b9e\u73b0\u4e8c\u5206\u67e5\u627e","text":"

    \u5728\u4e4b\u524d\u7684\u7ae0\u8282\u4e2d\uff0c\u4e8c\u5206\u67e5\u627e\u662f\u57fa\u4e8e\u9012\u63a8\uff08\u8fed\u4ee3\uff09\u5b9e\u73b0\u7684\u3002\u73b0\u5728\u6211\u4eec\u57fa\u4e8e\u5206\u6cbb\uff08\u9012\u5f52\uff09\u6765\u5b9e\u73b0\u5b83\u3002

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6709\u5e8f\u6570\u7ec4 nums \uff0c\u5176\u4e2d\u6240\u6709\u5143\u7d20\u90fd\u662f\u552f\u4e00\u7684\uff0c\u8bf7\u67e5\u627e\u5143\u7d20 target \u3002

    \u4ece\u5206\u6cbb\u89d2\u5ea6\uff0c\u6211\u4eec\u5c06\u641c\u7d22\u533a\u95f4 \\([i, j]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\u8bb0\u4e3a \\(f(i, j)\\) \u3002

    \u4ee5\u539f\u95ee\u9898 \\(f(0, n-1)\\) \u4e3a\u8d77\u59cb\u70b9\uff0c\u901a\u8fc7\u4ee5\u4e0b\u6b65\u9aa4\u8fdb\u884c\u4e8c\u5206\u67e5\u627e\u3002

    1. \u8ba1\u7b97\u641c\u7d22\u533a\u95f4 \\([i, j]\\) \u7684\u4e2d\u70b9 \\(m\\) \uff0c\u6839\u636e\u5b83\u6392\u9664\u4e00\u534a\u641c\u7d22\u533a\u95f4\u3002
    2. \u9012\u5f52\u6c42\u89e3\u89c4\u6a21\u51cf\u5c0f\u4e00\u534a\u7684\u5b50\u95ee\u9898\uff0c\u53ef\u80fd\u4e3a \\(f(i, m-1)\\) \u6216 \\(f(m+1, j)\\) \u3002
    3. \u5faa\u73af\u7b2c 1. \u6b65\u548c\u7b2c 2. \u6b65\uff0c\u76f4\u81f3\u627e\u5230 target \u6216\u533a\u95f4\u4e3a\u7a7a\u65f6\u8fd4\u56de\u3002

    \u56fe 12-4 \u5c55\u793a\u4e86\u5728\u6570\u7ec4\u4e2d\u4e8c\u5206\u67e5\u627e\u5143\u7d20 \\(6\\) \u7684\u5206\u6cbb\u8fc7\u7a0b\u3002

    \u56fe 12-4 \u00a0 \u4e8c\u5206\u67e5\u627e\u7684\u5206\u6cbb\u8fc7\u7a0b

    \u5728\u5b9e\u73b0\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u58f0\u660e\u4e00\u4e2a\u9012\u5f52\u51fd\u6570 dfs() \u6765\u6c42\u89e3\u95ee\u9898 \\(f(i, j)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_recur.py
    def dfs(nums: list[int], target: int, i: int, j: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j)\"\"\"\n    # \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if i > j:\n        return -1\n    # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    m = (i + j) // 2\n    if nums[m] < target:\n        # \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j)\n    elif nums[m] > target:\n        # \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1)\n    else:\n        # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m\n\ndef binary_search(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\"\"\"\n    n = len(nums)\n    # \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n
    binary_search_recur.cpp
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint dfs(vector<int> &nums, int target, int i, int j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    int m = (i + j) / 2;\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint binarySearch(vector<int> &nums, int target) {\n    int n = nums.size();\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.java
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint dfs(int[] nums, int target, int i, int j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    int m = (i + j) / 2;\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint binarySearch(int[] nums, int target) {\n    int n = nums.length;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.cs
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint DFS(int[] nums, int target, int i, int j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    int m = (i + j) / 2;\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return DFS(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return DFS(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint BinarySearch(int[] nums, int target) {\n    int n = nums.Length;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return DFS(nums, target, 0, n - 1);\n}\n
    binary_search_recur.go
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfunc dfs(nums []int, target, i, j int) int {\n    // \u5982\u679c\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u6ca1\u6709\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if i > j {\n        return -1\n    }\n    //    \u8ba1\u7b97\u7d22\u5f15\u4e2d\u70b9\n    m := i + ((j - i) >> 1)\n    //\u5224\u65ad\u4e2d\u70b9\u4e0e\u76ee\u6807\u5143\u7d20\u5927\u5c0f\n    if nums[m] < target {\n        // \u5c0f\u4e8e\u5219\u9012\u5f52\u53f3\u534a\u6570\u7ec4\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m+1, j)\n    } else if nums[m] > target {\n        // \u5c0f\u4e8e\u5219\u9012\u5f52\u5de6\u534a\u6570\u7ec4\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m-1)\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfunc binarySearch(nums []int, target int) int {\n    n := len(nums)\n    return dfs(nums, target, 0, n-1)\n}\n
    binary_search_recur.swift
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfunc dfs(nums: [Int], target: Int, i: Int, j: Int) -> Int {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if i > j {\n        return -1\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    let m = (i + j) / 2\n    if nums[m] < target {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums: nums, target: target, i: m + 1, j: j)\n    } else if nums[m] > target {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums: nums, target: target, i: i, j: m - 1)\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfunc binarySearch(nums: [Int], target: Int) -> Int {\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    dfs(nums: nums, target: target, i: nums.startIndex, j: nums.endIndex - 1)\n}\n
    binary_search_recur.js
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfunction dfs(nums, target, i, j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    const m = i + ((j - i) >> 1);\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfunction binarySearch(nums, target) {\n    const n = nums.length;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.ts
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfunction dfs(nums: number[], target: number, i: number, j: number): number {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    const m = i + ((j - i) >> 1);\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfunction binarySearch(nums: number[], target: number): number {\n    const n = nums.length;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.dart
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint dfs(List<int> nums, int target, int i, int j) {\n  // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n  if (i > j) {\n    return -1;\n  }\n  // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n  int m = (i + j) ~/ 2;\n  if (nums[m] < target) {\n    // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n    return dfs(nums, target, m + 1, j);\n  } else if (nums[m] > target) {\n    // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n    return dfs(nums, target, i, m - 1);\n  } else {\n    // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n    return m;\n  }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint binarySearch(List<int> nums, int target) {\n  int n = nums.length;\n  // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n  return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.rs
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfn dfs(nums: &[i32], target: i32, i: i32, j: i32) -> i32 {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if i > j {\n        return -1;\n    }\n    let m: i32 = (i + j) / 2;\n    if nums[m as usize] < target {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if nums[m as usize] > target {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfn binary_search(nums: &[i32], target: i32) -> i32 {\n    let n = nums.len() as i32;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    dfs(nums, target, 0, n - 1)\n}\n
    binary_search_recur.c
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nint dfs(int nums[], int target, int i, int j) {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1;\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    int m = (i + j) / 2;\n    if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        return dfs(nums, target, m + 1, j);\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        return dfs(nums, target, i, m - 1);\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        return m;\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nint binarySearch(int nums[], int target, int numsSize) {\n    int n = numsSize;\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1);\n}\n
    binary_search_recur.kt
    /* \u4e8c\u5206\u67e5\u627e\uff1a\u95ee\u9898 f(i, j) */\nfun dfs(\n    nums: IntArray,\n    target: Int,\n    i: Int,\n    j: Int\n): Int {\n    // \u82e5\u533a\u95f4\u4e3a\u7a7a\uff0c\u4ee3\u8868\u65e0\u76ee\u6807\u5143\u7d20\uff0c\u5219\u8fd4\u56de -1\n    if (i > j) {\n        return -1\n    }\n    // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    val m = (i + j) / 2\n    return if (nums[m] < target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(m+1, j)\n        dfs(nums, target, m + 1, j)\n    } else if (nums[m] > target) {\n        // \u9012\u5f52\u5b50\u95ee\u9898 f(i, m-1)\n        dfs(nums, target, i, m - 1)\n    } else {\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        m\n    }\n}\n\n/* \u4e8c\u5206\u67e5\u627e */\nfun binarySearch(nums: IntArray, target: Int): Int {\n    val n = nums.size\n    // \u6c42\u89e3\u95ee\u9898 f(0, n-1)\n    return dfs(nums, target, 0, n - 1)\n}\n
    binary_search_recur.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{binary_search}\n
    binary_search_recur.zig
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{binarySearch}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/","title":"12.3 \u00a0 \u6784\u5efa\u4e8c\u53c9\u6811\u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a\u4e00\u68f5\u4e8c\u53c9\u6811\u7684\u524d\u5e8f\u904d\u5386 preorder \u548c\u4e2d\u5e8f\u904d\u5386 inorder \uff0c\u8bf7\u4ece\u4e2d\u6784\u5efa\u4e8c\u53c9\u6811\uff0c\u8fd4\u56de\u4e8c\u53c9\u6811\u7684\u6839\u8282\u70b9\u3002\u5047\u8bbe\u4e8c\u53c9\u6811\u4e2d\u6ca1\u6709\u503c\u91cd\u590d\u7684\u8282\u70b9\uff08\u5982\u56fe 12-5 \u6240\u793a\uff09\u3002

    \u56fe 12-5 \u00a0 \u6784\u5efa\u4e8c\u53c9\u6811\u7684\u793a\u4f8b\u6570\u636e

    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#1","title":"1. \u00a0 \u5224\u65ad\u662f\u5426\u4e3a\u5206\u6cbb\u95ee\u9898","text":"

    \u539f\u95ee\u9898\u5b9a\u4e49\u4e3a\u4ece preorder \u548c inorder \u6784\u5efa\u4e8c\u53c9\u6811\uff0c\u662f\u4e00\u4e2a\u5178\u578b\u7684\u5206\u6cbb\u95ee\u9898\u3002

    • \u95ee\u9898\u53ef\u4ee5\u5206\u89e3\uff1a\u4ece\u5206\u6cbb\u7684\u89d2\u5ea6\u5207\u5165\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u539f\u95ee\u9898\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\u3001\u6784\u5efa\u53f3\u5b50\u6811\uff0c\u52a0\u4e0a\u4e00\u6b65\u64cd\u4f5c\uff1a\u521d\u59cb\u5316\u6839\u8282\u70b9\u3002\u800c\u5bf9\u4e8e\u6bcf\u68f5\u5b50\u6811\uff08\u5b50\u95ee\u9898\uff09\uff0c\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u590d\u7528\u4ee5\u4e0a\u5212\u5206\u65b9\u6cd5\uff0c\u5c06\u5176\u5212\u5206\u4e3a\u66f4\u5c0f\u7684\u5b50\u6811\uff08\u5b50\u95ee\u9898\uff09\uff0c\u76f4\u81f3\u8fbe\u5230\u6700\u5c0f\u5b50\u95ee\u9898\uff08\u7a7a\u5b50\u6811\uff09\u65f6\u7ec8\u6b62\u3002
    • \u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff1a\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u5b83\u4eec\u4e4b\u95f4\u6ca1\u6709\u4ea4\u96c6\u3002\u5728\u6784\u5efa\u5de6\u5b50\u6811\u65f6\uff0c\u6211\u4eec\u53ea\u9700\u5173\u6ce8\u4e2d\u5e8f\u904d\u5386\u548c\u524d\u5e8f\u904d\u5386\u4e2d\u4e0e\u5de6\u5b50\u6811\u5bf9\u5e94\u7684\u90e8\u5206\u3002\u53f3\u5b50\u6811\u540c\u7406\u3002
    • \u5b50\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u5408\u5e76\uff1a\u4e00\u65e6\u5f97\u5230\u4e86\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\uff08\u5b50\u95ee\u9898\u7684\u89e3\uff09\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5c06\u5b83\u4eec\u94fe\u63a5\u5230\u6839\u8282\u70b9\u4e0a\uff0c\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002
    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#2","title":"2. \u00a0 \u5982\u4f55\u5212\u5206\u5b50\u6811","text":"

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u8fd9\u9053\u9898\u53ef\u4ee5\u4f7f\u7528\u5206\u6cbb\u6765\u6c42\u89e3\uff0c\u4f46\u5982\u4f55\u901a\u8fc7\u524d\u5e8f\u904d\u5386 preorder \u548c\u4e2d\u5e8f\u904d\u5386 inorder \u6765\u5212\u5206\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u5462\uff1f

    \u6839\u636e\u5b9a\u4e49\uff0cpreorder \u548c inorder \u90fd\u53ef\u4ee5\u5212\u5206\u4e3a\u4e09\u4e2a\u90e8\u5206\u3002

    • \u524d\u5e8f\u904d\u5386\uff1a[ \u6839\u8282\u70b9 | \u5de6\u5b50\u6811 | \u53f3\u5b50\u6811 ] \uff0c\u4f8b\u5982\u56fe 12-5 \u7684\u6811\u5bf9\u5e94 [ 3 | 9 | 2 1 7 ] \u3002
    • \u4e2d\u5e8f\u904d\u5386\uff1a[ \u5de6\u5b50\u6811 | \u6839\u8282\u70b9 \uff5c \u53f3\u5b50\u6811 ] \uff0c\u4f8b\u5982\u56fe 12-5 \u7684\u6811\u5bf9\u5e94 [ 9 | 3 | 1 2 7 ] \u3002

    \u4ee5\u4e0a\u56fe\u6570\u636e\u4e3a\u4f8b\uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u56fe 12-6 \u6240\u793a\u7684\u6b65\u9aa4\u5f97\u5230\u5212\u5206\u7ed3\u679c\u3002

    1. \u524d\u5e8f\u904d\u5386\u7684\u9996\u5143\u7d20 3 \u662f\u6839\u8282\u70b9\u7684\u503c\u3002
    2. \u67e5\u627e\u6839\u8282\u70b9 3 \u5728 inorder \u4e2d\u7684\u7d22\u5f15\uff0c\u5229\u7528\u8be5\u7d22\u5f15\u53ef\u5c06 inorder \u5212\u5206\u4e3a [ 9 | 3 \uff5c 1 2 7 ] \u3002
    3. \u6839\u636e inorder \u7684\u5212\u5206\u7ed3\u679c\uff0c\u6613\u5f97\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\u7684\u8282\u70b9\u6570\u91cf\u5206\u522b\u4e3a 1 \u548c 3 \uff0c\u4ece\u800c\u53ef\u5c06 preorder \u5212\u5206\u4e3a [ 3 | 9 | 2 1 7 ] \u3002

    \u56fe 12-6 \u00a0 \u5728\u524d\u5e8f\u904d\u5386\u548c\u4e2d\u5e8f\u904d\u5386\u4e2d\u5212\u5206\u5b50\u6811

    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#3","title":"3. \u00a0 \u57fa\u4e8e\u53d8\u91cf\u63cf\u8ff0\u5b50\u6811\u533a\u95f4","text":"

    \u6839\u636e\u4ee5\u4e0a\u5212\u5206\u65b9\u6cd5\uff0c\u6211\u4eec\u5df2\u7ecf\u5f97\u5230\u6839\u8282\u70b9\u3001\u5de6\u5b50\u6811\u3001\u53f3\u5b50\u6811\u5728 preorder \u548c inorder \u4e2d\u7684\u7d22\u5f15\u533a\u95f4\u3002\u800c\u4e3a\u4e86\u63cf\u8ff0\u8fd9\u4e9b\u7d22\u5f15\u533a\u95f4\uff0c\u6211\u4eec\u9700\u8981\u501f\u52a9\u51e0\u4e2a\u6307\u9488\u53d8\u91cf\u3002

    • \u5c06\u5f53\u524d\u6811\u7684\u6839\u8282\u70b9\u5728 preorder \u4e2d\u7684\u7d22\u5f15\u8bb0\u4e3a \\(i\\) \u3002
    • \u5c06\u5f53\u524d\u6811\u7684\u6839\u8282\u70b9\u5728 inorder \u4e2d\u7684\u7d22\u5f15\u8bb0\u4e3a \\(m\\) \u3002
    • \u5c06\u5f53\u524d\u6811\u5728 inorder \u4e2d\u7684\u7d22\u5f15\u533a\u95f4\u8bb0\u4e3a \\([l, r]\\) \u3002

    \u5982\u8868 12-1 \u6240\u793a\uff0c\u901a\u8fc7\u4ee5\u4e0a\u53d8\u91cf\u5373\u53ef\u8868\u793a\u6839\u8282\u70b9\u5728 preorder \u4e2d\u7684\u7d22\u5f15\uff0c\u4ee5\u53ca\u5b50\u6811\u5728 inorder \u4e2d\u7684\u7d22\u5f15\u533a\u95f4\u3002

    \u8868 12-1 \u00a0 \u6839\u8282\u70b9\u548c\u5b50\u6811\u5728\u524d\u5e8f\u904d\u5386\u548c\u4e2d\u5e8f\u904d\u5386\u4e2d\u7684\u7d22\u5f15

    \u6839\u8282\u70b9\u5728 preorder \u4e2d\u7684\u7d22\u5f15 \u5b50\u6811\u5728 inorder \u4e2d\u7684\u7d22\u5f15\u533a\u95f4 \u5f53\u524d\u6811 \\(i\\) \\([l, r]\\) \u5de6\u5b50\u6811 \\(i + 1\\) \\([l, m-1]\\) \u53f3\u5b50\u6811 \\(i + 1 + (m - l)\\) \\([m+1, r]\\)

    \u8bf7\u6ce8\u610f\uff0c\u53f3\u5b50\u6811\u6839\u8282\u70b9\u7d22\u5f15\u4e2d\u7684 \\((m-l)\\) \u7684\u542b\u4e49\u662f\u201c\u5de6\u5b50\u6811\u7684\u8282\u70b9\u6570\u91cf\u201d\uff0c\u5efa\u8bae\u7ed3\u5408\u56fe 12-7 \u7406\u89e3\u3002

    \u56fe 12-7 \u00a0 \u6839\u8282\u70b9\u548c\u5de6\u53f3\u5b50\u6811\u7684\u7d22\u5f15\u533a\u95f4\u8868\u793a

    "},{"location":"chapter_divide_and_conquer/build_binary_tree_problem/#4","title":"4. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u4e3a\u4e86\u63d0\u5347\u67e5\u8be2 \\(m\\) \u7684\u6548\u7387\uff0c\u6211\u4eec\u501f\u52a9\u4e00\u4e2a\u54c8\u5e0c\u8868 hmap \u6765\u5b58\u50a8\u6570\u7ec4 inorder \u4e2d\u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig build_tree.py
    def dfs(\n    preorder: list[int],\n    inorder_map: dict[int, int],\n    i: int,\n    l: int,\n    r: int,\n) -> TreeNode | None:\n    \"\"\"\u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb\"\"\"\n    # \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if r - l < 0:\n        return None\n    # \u521d\u59cb\u5316\u6839\u8282\u70b9\n    root = TreeNode(preorder[i])\n    # \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    m = inorder_map[preorder[i]]\n    # \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)\n    # \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)\n    # \u8fd4\u56de\u6839\u8282\u70b9\n    return root\n\ndef build_tree(preorder: list[int], inorder: list[int]) -> TreeNode | None:\n    \"\"\"\u6784\u5efa\u4e8c\u53c9\u6811\"\"\"\n    # \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    inorder_map = {val: i for i, val in enumerate(inorder)}\n    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)\n    return root\n
    build_tree.cpp
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode *dfs(vector<int> &preorder, unordered_map<int, int> &inorderMap, int i, int l, int r) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0)\n        return NULL;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    TreeNode *root = new TreeNode(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    int m = inorderMap[preorder[i]];\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root->left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    unordered_map<int, int> inorderMap;\n    for (int i = 0; i < inorder.size(); i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);\n    return root;\n}\n
    build_tree.java
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0)\n        return null;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    TreeNode root = new TreeNode(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    int m = inorderMap.get(preorder[i]);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode buildTree(int[] preorder, int[] inorder) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    Map<Integer, Integer> inorderMap = new HashMap<>();\n    for (int i = 0; i < inorder.length; i++) {\n        inorderMap.put(inorder[i], i);\n    }\n    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n
    build_tree.cs
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode? DFS(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0)\n        return null;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    TreeNode root = new(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    int m = inorderMap[preorder[i]];\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode? BuildTree(int[] preorder, int[] inorder) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    Dictionary<int, int> inorderMap = [];\n    for (int i = 0; i < inorder.Length; i++) {\n        inorderMap.TryAdd(inorder[i], i);\n    }\n    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);\n    return root;\n}\n
    build_tree.go
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfunc dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if r-l < 0 {\n        return nil\n    }\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    root := NewTreeNode(preorder[i])\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    m := inorderMap[preorder[i]]\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfunc buildTree(preorder, inorder []int) *TreeNode {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    inorderMap := make(map[int]int, len(inorder))\n    for i := 0; i < len(inorder); i++ {\n        inorderMap[inorder[i]] = i\n    }\n\n    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)\n    return root\n}\n
    build_tree.swift
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfunc dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if r - l < 0 {\n        return nil\n    }\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    let root = TreeNode(x: preorder[i])\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    let m = inorderMap[preorder[i]]!\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfunc buildTree(preorder: [Int], inorder: [Int]) -> TreeNode? {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }\n    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)\n}\n
    build_tree.js
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfunction dfs(preorder, inorderMap, i, l, r) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0) return null;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    const root = new TreeNode(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    const m = inorderMap.get(preorder[i]);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfunction buildTree(preorder, inorder) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    let inorderMap = new Map();\n    for (let i = 0; i < inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n
    build_tree.ts
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfunction dfs(\n    preorder: number[],\n    inorderMap: Map<number, number>,\n    i: number,\n    l: number,\n    r: number\n): TreeNode | null {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0) return null;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    const root: TreeNode = new TreeNode(preorder[i]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    const m = inorderMap.get(preorder[i]);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfunction buildTree(preorder: number[], inorder: number[]): TreeNode | null {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    let inorderMap = new Map<number, number>();\n    for (let i = 0; i < inorder.length; i++) {\n        inorderMap.set(inorder[i], i);\n    }\n    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n    return root;\n}\n
    build_tree.dart
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode? dfs(\n  List<int> preorder,\n  Map<int, int> inorderMap,\n  int i,\n  int l,\n  int r,\n) {\n  // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n  if (r - l < 0) {\n    return null;\n  }\n  // \u521d\u59cb\u5316\u6839\u8282\u70b9\n  TreeNode? root = TreeNode(preorder[i]);\n  // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n  int m = inorderMap[preorder[i]]!;\n  // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);\n  // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);\n  // \u8fd4\u56de\u6839\u8282\u70b9\n  return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode? buildTree(List<int> preorder, List<int> inorder) {\n  // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n  Map<int, int> inorderMap = {};\n  for (int i = 0; i < inorder.length; i++) {\n    inorderMap[inorder[i]] = i;\n  }\n  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);\n  return root;\n}\n
    build_tree.rs
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfn dfs(\n    preorder: &[i32],\n    inorder_map: &HashMap<i32, i32>,\n    i: i32,\n    l: i32,\n    r: i32,\n) -> Option<Rc<RefCell<TreeNode>>> {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if r - l < 0 {\n        return None;\n    }\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    let root = TreeNode::new(preorder[i as usize]);\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    let m = inorder_map.get(&preorder[i as usize]).unwrap();\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    Some(root)\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    let mut inorder_map: HashMap<i32, i32> = HashMap::new();\n    for i in 0..inorder.len() {\n        inorder_map.insert(inorder[i], i as i32);\n    }\n    let root = dfs(preorder, &inorder_map, 0, 0, inorder.len() as i32 - 1);\n    root\n}\n
    build_tree.c
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nTreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0)\n        return NULL;\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));\n    root->val = preorder[i];\n    root->left = NULL;\n    root->right = NULL;\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    int m = inorderMap[preorder[i]];\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root->left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root;\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nTreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);\n    for (int i = 0; i < inorderSize; i++) {\n        inorderMap[inorder[i]] = i;\n    }\n    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);\n    free(inorderMap);\n    return root;\n}\n
    build_tree.kt
    /* \u6784\u5efa\u4e8c\u53c9\u6811\uff1a\u5206\u6cbb */\nfun dfs(preorder: IntArray, inorderMap: Map<Int?, Int?>, i: Int, l: Int, r: Int): TreeNode? {\n    // \u5b50\u6811\u533a\u95f4\u4e3a\u7a7a\u65f6\u7ec8\u6b62\n    if (r - l < 0) return null\n    // \u521d\u59cb\u5316\u6839\u8282\u70b9\n    val root = TreeNode(preorder[i])\n    // \u67e5\u8be2 m \uff0c\u4ece\u800c\u5212\u5206\u5de6\u53f3\u5b50\u6811\n    val m = inorderMap[preorder[i]]!!\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u5de6\u5b50\u6811\n    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)\n    // \u5b50\u95ee\u9898\uff1a\u6784\u5efa\u53f3\u5b50\u6811\n    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)\n    // \u8fd4\u56de\u6839\u8282\u70b9\n    return root\n}\n\n/* \u6784\u5efa\u4e8c\u53c9\u6811 */\nfun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {\n    // \u521d\u59cb\u5316\u54c8\u5e0c\u8868\uff0c\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\n    val inorderMap: MutableMap<Int?, Int?> = HashMap()\n    for (i in inorder.indices) {\n        inorderMap[inorder[i]] = i\n    }\n    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)\n    return root\n}\n
    build_tree.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{build_tree}\n
    build_tree.zig
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{buildTree}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 12-8 \u5c55\u793a\u4e86\u6784\u5efa\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u8fc7\u7a0b\uff0c\u5404\u4e2a\u8282\u70b9\u662f\u5728\u5411\u4e0b\u201c\u9012\u201d\u7684\u8fc7\u7a0b\u4e2d\u5efa\u7acb\u7684\uff0c\u800c\u5404\u6761\u8fb9\uff08\u5f15\u7528\uff09\u662f\u5728\u5411\u4e0a\u201c\u5f52\u201d\u7684\u8fc7\u7a0b\u4e2d\u5efa\u7acb\u7684\u3002

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

    \u56fe 12-8 \u00a0 \u6784\u5efa\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u8fc7\u7a0b

    \u6bcf\u4e2a\u9012\u5f52\u51fd\u6570\u5185\u7684\u524d\u5e8f\u904d\u5386 preorder \u548c\u4e2d\u5e8f\u904d\u5386 inorder \u7684\u5212\u5206\u7ed3\u679c\u5982\u56fe 12-9 \u6240\u793a\u3002

    \u56fe 12-9 \u00a0 \u6bcf\u4e2a\u9012\u5f52\u51fd\u6570\u4e2d\u7684\u5212\u5206\u7ed3\u679c

    \u8bbe\u6811\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(n\\) \uff0c\u521d\u59cb\u5316\u6bcf\u4e00\u4e2a\u8282\u70b9\uff08\u6267\u884c\u4e00\u4e2a\u9012\u5f52\u51fd\u6570 dfs() \uff09\u4f7f\u7528 \\(O(1)\\) \u65f6\u95f4\u3002\u56e0\u6b64\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    \u54c8\u5e0c\u8868\u5b58\u50a8 inorder \u5143\u7d20\u5230\u7d22\u5f15\u7684\u6620\u5c04\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u5373\u4e8c\u53c9\u6811\u9000\u5316\u4e3a\u94fe\u8868\u65f6\uff0c\u9012\u5f52\u6df1\u5ea6\u8fbe\u5230 \\(n\\) \uff0c\u4f7f\u7528 \\(O(n)\\) \u7684\u6808\u5e27\u7a7a\u95f4\u3002\u56e0\u6b64\u603b\u4f53\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/","title":"12.1 \u00a0 \u5206\u6cbb\u7b97\u6cd5","text":"

    \u300c\u5206\u6cbb divide and conquer\u300d\uff0c\u5168\u79f0\u5206\u800c\u6cbb\u4e4b\uff0c\u662f\u4e00\u79cd\u975e\u5e38\u91cd\u8981\u4e14\u5e38\u89c1\u7684\u7b97\u6cd5\u7b56\u7565\u3002\u5206\u6cbb\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u5b9e\u73b0\uff0c\u5305\u62ec\u201c\u5206\u201d\u548c\u201c\u6cbb\u201d\u4e24\u4e2a\u6b65\u9aa4\u3002

    1. \u5206\uff08\u5212\u5206\u9636\u6bb5\uff09\uff1a\u9012\u5f52\u5730\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u4e24\u4e2a\u6216\u591a\u4e2a\u5b50\u95ee\u9898\uff0c\u76f4\u81f3\u5230\u8fbe\u6700\u5c0f\u5b50\u95ee\u9898\u65f6\u7ec8\u6b62\u3002
    2. \u6cbb\uff08\u5408\u5e76\u9636\u6bb5\uff09\uff1a\u4ece\u5df2\u77e5\u89e3\u7684\u6700\u5c0f\u5b50\u95ee\u9898\u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5730\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u8fdb\u884c\u5408\u5e76\uff0c\u4ece\u800c\u6784\u5efa\u51fa\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u5982\u56fe 12-1 \u6240\u793a\uff0c\u201c\u5f52\u5e76\u6392\u5e8f\u201d\u662f\u5206\u6cbb\u7b56\u7565\u7684\u5178\u578b\u5e94\u7528\u4e4b\u4e00\u3002

    1. \u5206\uff1a\u9012\u5f52\u5730\u5c06\u539f\u6570\u7ec4\uff08\u539f\u95ee\u9898\uff09\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff08\u5b50\u95ee\u9898\uff09\uff0c\u76f4\u5230\u5b50\u6570\u7ec4\u53ea\u5269\u4e00\u4e2a\u5143\u7d20\uff08\u6700\u5c0f\u5b50\u95ee\u9898\uff09\u3002
    2. \u6cbb\uff1a\u4ece\u5e95\u81f3\u9876\u5730\u5c06\u6709\u5e8f\u7684\u5b50\u6570\u7ec4\uff08\u5b50\u95ee\u9898\u7684\u89e3\uff09\u8fdb\u884c\u5408\u5e76\uff0c\u4ece\u800c\u5f97\u5230\u6709\u5e8f\u7684\u539f\u6570\u7ec4\uff08\u539f\u95ee\u9898\u7684\u89e3\uff09\u3002

    \u56fe 12-1 \u00a0 \u5f52\u5e76\u6392\u5e8f\u7684\u5206\u6cbb\u7b56\u7565

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1211","title":"12.1.1 \u00a0 \u5982\u4f55\u5224\u65ad\u5206\u6cbb\u95ee\u9898","text":"

    \u4e00\u4e2a\u95ee\u9898\u662f\u5426\u9002\u5408\u4f7f\u7528\u5206\u6cbb\u89e3\u51b3\uff0c\u901a\u5e38\u53ef\u4ee5\u53c2\u8003\u4ee5\u4e0b\u51e0\u4e2a\u5224\u65ad\u4f9d\u636e\u3002

    1. \u95ee\u9898\u53ef\u4ee5\u5206\u89e3\uff1a\u539f\u95ee\u9898\u53ef\u4ee5\u5206\u89e3\u6210\u89c4\u6a21\u66f4\u5c0f\u3001\u7c7b\u4f3c\u7684\u5b50\u95ee\u9898\uff0c\u4ee5\u53ca\u80fd\u591f\u4ee5\u76f8\u540c\u65b9\u5f0f\u9012\u5f52\u5730\u8fdb\u884c\u5212\u5206\u3002
    2. \u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff1a\u5b50\u95ee\u9898\u4e4b\u95f4\u6ca1\u6709\u91cd\u53e0\uff0c\u4e92\u4e0d\u4f9d\u8d56\uff0c\u53ef\u4ee5\u72ec\u7acb\u89e3\u51b3\u3002
    3. \u5b50\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u5408\u5e76\uff1a\u539f\u95ee\u9898\u7684\u89e3\u901a\u8fc7\u5408\u5e76\u5b50\u95ee\u9898\u7684\u89e3\u5f97\u6765\u3002

    \u663e\u7136\uff0c\u5f52\u5e76\u6392\u5e8f\u6ee1\u8db3\u4ee5\u4e0a\u4e09\u4e2a\u5224\u65ad\u4f9d\u636e\u3002

    1. \u95ee\u9898\u53ef\u4ee5\u5206\u89e3\uff1a\u9012\u5f52\u5730\u5c06\u6570\u7ec4\uff08\u539f\u95ee\u9898\uff09\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff08\u5b50\u95ee\u9898\uff09\u3002
    2. \u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff1a\u6bcf\u4e2a\u5b50\u6570\u7ec4\u90fd\u53ef\u4ee5\u72ec\u7acb\u5730\u8fdb\u884c\u6392\u5e8f\uff08\u5b50\u95ee\u9898\u53ef\u4ee5\u72ec\u7acb\u8fdb\u884c\u6c42\u89e3\uff09\u3002
    3. \u5b50\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u5408\u5e76\uff1a\u4e24\u4e2a\u6709\u5e8f\u5b50\u6570\u7ec4\uff08\u5b50\u95ee\u9898\u7684\u89e3\uff09\u53ef\u4ee5\u5408\u5e76\u4e3a\u4e00\u4e2a\u6709\u5e8f\u6570\u7ec4\uff08\u539f\u95ee\u9898\u7684\u89e3\uff09\u3002
    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1212","title":"12.1.2 \u00a0 \u901a\u8fc7\u5206\u6cbb\u63d0\u5347\u6548\u7387","text":"

    \u5206\u6cbb\u4e0d\u4ec5\u53ef\u4ee5\u6709\u6548\u5730\u89e3\u51b3\u7b97\u6cd5\u95ee\u9898\uff0c\u5f80\u5f80\u8fd8\u53ef\u4ee5\u63d0\u5347\u7b97\u6cd5\u6548\u7387\u3002\u5728\u6392\u5e8f\u7b97\u6cd5\u4e2d\uff0c\u5feb\u901f\u6392\u5e8f\u3001\u5f52\u5e76\u6392\u5e8f\u3001\u5806\u6392\u5e8f\u76f8\u8f83\u4e8e\u9009\u62e9\u3001\u5192\u6ce1\u3001\u63d2\u5165\u6392\u5e8f\u66f4\u5feb\uff0c\u5c31\u662f\u56e0\u4e3a\u5b83\u4eec\u5e94\u7528\u4e86\u5206\u6cbb\u7b56\u7565\u3002

    \u90a3\u4e48\uff0c\u6211\u4eec\u4e0d\u7981\u53d1\u95ee\uff1a\u4e3a\u4ec0\u4e48\u5206\u6cbb\u53ef\u4ee5\u63d0\u5347\u7b97\u6cd5\u6548\u7387\uff0c\u5176\u5e95\u5c42\u903b\u8f91\u662f\u4ec0\u4e48\uff1f\u6362\u53e5\u8bdd\u8bf4\uff0c\u5c06\u5927\u95ee\u9898\u5206\u89e3\u4e3a\u591a\u4e2a\u5b50\u95ee\u9898\u3001\u89e3\u51b3\u5b50\u95ee\u9898\u3001\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u5408\u5e76\u4e3a\u539f\u95ee\u9898\u7684\u89e3\uff0c\u8fd9\u51e0\u6b65\u7684\u6548\u7387\u4e3a\u4ec0\u4e48\u6bd4\u76f4\u63a5\u89e3\u51b3\u539f\u95ee\u9898\u7684\u6548\u7387\u66f4\u9ad8\uff1f\u8fd9\u4e2a\u95ee\u9898\u53ef\u4ee5\u4ece\u64cd\u4f5c\u6570\u91cf\u548c\u5e76\u884c\u8ba1\u7b97\u4e24\u65b9\u9762\u6765\u8ba8\u8bba\u3002

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1","title":"1. \u00a0 \u64cd\u4f5c\u6570\u91cf\u4f18\u5316","text":"

    \u4ee5\u201c\u5192\u6ce1\u6392\u5e8f\u201d\u4e3a\u4f8b\uff0c\u5176\u5904\u7406\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6570\u7ec4\u9700\u8981 \\(O(n^2)\\) \u65f6\u95f4\u3002\u5047\u8bbe\u6211\u4eec\u6309\u7167\u56fe 12-2 \u6240\u793a\u7684\u65b9\u5f0f\uff0c\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5904\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u5219\u5212\u5206\u9700\u8981 \\(O(n)\\) \u65f6\u95f4\uff0c\u6392\u5e8f\u6bcf\u4e2a\u5b50\u6570\u7ec4\u9700\u8981 \\(O((n / 2)^2)\\) \u65f6\u95f4\uff0c\u5408\u5e76\u4e24\u4e2a\u5b50\u6570\u7ec4\u9700\u8981 \\(O(n)\\) \u65f6\u95f4\uff0c\u603b\u4f53\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a\uff1a

    \\[ O(n + (\\frac{n}{2})^2 \\times 2 + n) = O(\\frac{n^2}{2} + 2n) \\]

    \u56fe 12-2 \u00a0 \u5212\u5206\u6570\u7ec4\u524d\u540e\u7684\u5192\u6ce1\u6392\u5e8f

    \u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u8ba1\u7b97\u4ee5\u4e0b\u4e0d\u7b49\u5f0f\uff0c\u5176\u5de6\u8fb9\u548c\u53f3\u8fb9\u5206\u522b\u4e3a\u5212\u5206\u524d\u548c\u5212\u5206\u540e\u7684\u64cd\u4f5c\u603b\u6570\uff1a

    \\[ \\begin{aligned} n^2 & > \\frac{n^2}{2} + 2n \\newline n^2 - \\frac{n^2}{2} - 2n & > 0 \\newline n(n - 4) & > 0 \\end{aligned} \\]

    \u8fd9\u610f\u5473\u7740\u5f53 \\(n > 4\\) \u65f6\uff0c\u5212\u5206\u540e\u7684\u64cd\u4f5c\u6570\u91cf\u66f4\u5c11\uff0c\u6392\u5e8f\u6548\u7387\u5e94\u8be5\u66f4\u9ad8\u3002\u8bf7\u6ce8\u610f\uff0c\u5212\u5206\u540e\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4ecd\u7136\u662f\u5e73\u65b9\u9636 \\(O(n^2)\\) \uff0c\u53ea\u662f\u590d\u6742\u5ea6\u4e2d\u7684\u5e38\u6570\u9879\u53d8\u5c0f\u4e86\u3002

    \u8fdb\u4e00\u6b65\u60f3\uff0c\u5982\u679c\u6211\u4eec\u628a\u5b50\u6570\u7ec4\u4e0d\u65ad\u5730\u518d\u4ece\u4e2d\u70b9\u5904\u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u53ea\u5269\u4e00\u4e2a\u5143\u7d20\u65f6\u505c\u6b62\u5212\u5206\u5462\uff1f\u8fd9\u79cd\u601d\u8def\u5b9e\u9645\u4e0a\u5c31\u662f\u201c\u5f52\u5e76\u6392\u5e8f\u201d\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    \u518d\u601d\u8003\uff0c\u5982\u679c\u6211\u4eec\u591a\u8bbe\u7f6e\u51e0\u4e2a\u5212\u5206\u70b9\uff0c\u5c06\u539f\u6570\u7ec4\u5e73\u5747\u5212\u5206\u4e3a \\(k\\) \u4e2a\u5b50\u6570\u7ec4\u5462\uff1f\u8fd9\u79cd\u60c5\u51b5\u4e0e\u201c\u6876\u6392\u5e8f\u201d\u975e\u5e38\u7c7b\u4f3c\uff0c\u5b83\u975e\u5e38\u9002\u5408\u6392\u5e8f\u6d77\u91cf\u6570\u636e\uff0c\u7406\u8bba\u4e0a\u65f6\u95f4\u590d\u6742\u5ea6\u53ef\u4ee5\u8fbe\u5230 \\(O(n + k)\\) \u3002

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#2","title":"2. \u00a0 \u5e76\u884c\u8ba1\u7b97\u4f18\u5316","text":"

    \u6211\u4eec\u77e5\u9053\uff0c\u5206\u6cbb\u751f\u6210\u7684\u5b50\u95ee\u9898\u662f\u76f8\u4e92\u72ec\u7acb\u7684\uff0c\u56e0\u6b64\u901a\u5e38\u53ef\u4ee5\u5e76\u884c\u89e3\u51b3\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u5206\u6cbb\u4e0d\u4ec5\u53ef\u4ee5\u964d\u4f4e\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\uff0c\u8fd8\u6709\u5229\u4e8e\u64cd\u4f5c\u7cfb\u7edf\u7684\u5e76\u884c\u4f18\u5316\u3002

    \u5e76\u884c\u4f18\u5316\u5728\u591a\u6838\u6216\u591a\u5904\u7406\u5668\u7684\u73af\u5883\u4e2d\u5c24\u5176\u6709\u6548\uff0c\u56e0\u4e3a\u7cfb\u7edf\u53ef\u4ee5\u540c\u65f6\u5904\u7406\u591a\u4e2a\u5b50\u95ee\u9898\uff0c\u66f4\u52a0\u5145\u5206\u5730\u5229\u7528\u8ba1\u7b97\u8d44\u6e90\uff0c\u4ece\u800c\u663e\u8457\u51cf\u5c11\u603b\u4f53\u7684\u8fd0\u884c\u65f6\u95f4\u3002

    \u6bd4\u5982\u5728\u56fe 12-3 \u6240\u793a\u7684\u201c\u6876\u6392\u5e8f\u201d\u4e2d\uff0c\u6211\u4eec\u5c06\u6d77\u91cf\u7684\u6570\u636e\u5e73\u5747\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\uff0c\u5219\u53ef\u6240\u6709\u6876\u7684\u6392\u5e8f\u4efb\u52a1\u5206\u6563\u5230\u5404\u4e2a\u8ba1\u7b97\u5355\u5143\uff0c\u5b8c\u6210\u540e\u518d\u5408\u5e76\u7ed3\u679c\u3002

    \u56fe 12-3 \u00a0 \u6876\u6392\u5e8f\u7684\u5e76\u884c\u8ba1\u7b97

    "},{"location":"chapter_divide_and_conquer/divide_and_conquer/#1213","title":"12.1.3 \u00a0 \u5206\u6cbb\u5e38\u89c1\u5e94\u7528","text":"

    \u4e00\u65b9\u9762\uff0c\u5206\u6cbb\u53ef\u4ee5\u7528\u6765\u89e3\u51b3\u8bb8\u591a\u7ecf\u5178\u7b97\u6cd5\u95ee\u9898\u3002

    • \u5bfb\u627e\u6700\u8fd1\u70b9\u5bf9\uff1a\u8be5\u7b97\u6cd5\u9996\u5148\u5c06\u70b9\u96c6\u5206\u6210\u4e24\u90e8\u5206\uff0c\u7136\u540e\u5206\u522b\u627e\u51fa\u4e24\u90e8\u5206\u4e2d\u7684\u6700\u8fd1\u70b9\u5bf9\uff0c\u6700\u540e\u627e\u51fa\u8de8\u8d8a\u4e24\u90e8\u5206\u7684\u6700\u8fd1\u70b9\u5bf9\u3002
    • \u5927\u6574\u6570\u4e58\u6cd5\uff1a\u4f8b\u5982 Karatsuba \u7b97\u6cd5\uff0c\u5b83\u5c06\u5927\u6574\u6570\u4e58\u6cd5\u5206\u89e3\u4e3a\u51e0\u4e2a\u8f83\u5c0f\u7684\u6574\u6570\u7684\u4e58\u6cd5\u548c\u52a0\u6cd5\u3002
    • \u77e9\u9635\u4e58\u6cd5\uff1a\u4f8b\u5982 Strassen \u7b97\u6cd5\uff0c\u5b83\u5c06\u5927\u77e9\u9635\u4e58\u6cd5\u5206\u89e3\u4e3a\u591a\u4e2a\u5c0f\u77e9\u9635\u7684\u4e58\u6cd5\u548c\u52a0\u6cd5\u3002
    • \u6c49\u8bfa\u5854\u95ee\u9898\uff1a\u6c49\u8bfa\u5854\u95ee\u9898\u53ef\u4ee5\u901a\u8fc7\u9012\u5f52\u89e3\u51b3\uff0c\u8fd9\u662f\u5178\u578b\u7684\u5206\u6cbb\u7b56\u7565\u5e94\u7528\u3002
    • \u6c42\u89e3\u9006\u5e8f\u5bf9\uff1a\u5728\u4e00\u4e2a\u5e8f\u5217\u4e2d\uff0c\u5982\u679c\u524d\u9762\u7684\u6570\u5b57\u5927\u4e8e\u540e\u9762\u7684\u6570\u5b57\uff0c\u90a3\u4e48\u8fd9\u4e24\u4e2a\u6570\u5b57\u6784\u6210\u4e00\u4e2a\u9006\u5e8f\u5bf9\u3002\u6c42\u89e3\u9006\u5e8f\u5bf9\u95ee\u9898\u53ef\u4ee5\u5229\u7528\u5206\u6cbb\u7684\u601d\u60f3\uff0c\u501f\u52a9\u5f52\u5e76\u6392\u5e8f\u8fdb\u884c\u6c42\u89e3\u3002

    \u53e6\u4e00\u65b9\u9762\uff0c\u5206\u6cbb\u5728\u7b97\u6cd5\u548c\u6570\u636e\u7ed3\u6784\u7684\u8bbe\u8ba1\u4e2d\u5e94\u7528\u5f97\u975e\u5e38\u5e7f\u6cdb\u3002

    • \u4e8c\u5206\u67e5\u627e\uff1a\u4e8c\u5206\u67e5\u627e\u662f\u5c06\u6709\u5e8f\u6570\u7ec4\u4ece\u4e2d\u70b9\u7d22\u5f15\u5904\u5206\u4e3a\u4e24\u90e8\u5206\uff0c\u7136\u540e\u6839\u636e\u76ee\u6807\u503c\u4e0e\u4e2d\u95f4\u5143\u7d20\u503c\u6bd4\u8f83\u7ed3\u679c\uff0c\u51b3\u5b9a\u6392\u9664\u54ea\u4e00\u534a\u533a\u95f4\uff0c\u5e76\u5728\u5269\u4f59\u533a\u95f4\u6267\u884c\u76f8\u540c\u7684\u4e8c\u5206\u64cd\u4f5c\u3002
    • \u5f52\u5e76\u6392\u5e8f\uff1a\u672c\u8282\u5f00\u5934\u5df2\u4ecb\u7ecd\uff0c\u4e0d\u518d\u8d58\u8ff0\u3002
    • \u5feb\u901f\u6392\u5e8f\uff1a\u5feb\u901f\u6392\u5e8f\u662f\u9009\u53d6\u4e00\u4e2a\u57fa\u51c6\u503c\uff0c\u7136\u540e\u628a\u6570\u7ec4\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u4e00\u4e2a\u5b50\u6570\u7ec4\u7684\u5143\u7d20\u6bd4\u57fa\u51c6\u503c\u5c0f\uff0c\u53e6\u4e00\u5b50\u6570\u7ec4\u7684\u5143\u7d20\u6bd4\u57fa\u51c6\u503c\u5927\uff0c\u518d\u5bf9\u8fd9\u4e24\u90e8\u5206\u8fdb\u884c\u76f8\u540c\u7684\u5212\u5206\u64cd\u4f5c\uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u53ea\u5269\u4e0b\u4e00\u4e2a\u5143\u7d20\u3002
    • \u6876\u6392\u5e8f\uff1a\u6876\u6392\u5e8f\u7684\u57fa\u672c\u601d\u60f3\u662f\u5c06\u6570\u636e\u5206\u6563\u5230\u591a\u4e2a\u6876\uff0c\u7136\u540e\u5bf9\u6bcf\u4e2a\u6876\u5185\u7684\u5143\u7d20\u8fdb\u884c\u6392\u5e8f\uff0c\u6700\u540e\u5c06\u5404\u4e2a\u6876\u7684\u5143\u7d20\u4f9d\u6b21\u53d6\u51fa\uff0c\u4ece\u800c\u5f97\u5230\u4e00\u4e2a\u6709\u5e8f\u6570\u7ec4\u3002
    • \u6811\uff1a\u4f8b\u5982\u4e8c\u53c9\u641c\u7d22\u6811\u3001AVL \u6811\u3001\u7ea2\u9ed1\u6811\u3001B \u6811\u3001B+ \u6811\u7b49\uff0c\u5b83\u4eec\u7684\u67e5\u627e\u3001\u63d2\u5165\u548c\u5220\u9664\u7b49\u64cd\u4f5c\u90fd\u53ef\u4ee5\u89c6\u4e3a\u5206\u6cbb\u7b56\u7565\u7684\u5e94\u7528\u3002
    • \u5806\uff1a\u5806\u662f\u4e00\u79cd\u7279\u6b8a\u7684\u5b8c\u5168\u4e8c\u53c9\u6811\uff0c\u5176\u5404\u79cd\u64cd\u4f5c\uff0c\u5982\u63d2\u5165\u3001\u5220\u9664\u548c\u5806\u5316\uff0c\u5b9e\u9645\u4e0a\u90fd\u9690\u542b\u4e86\u5206\u6cbb\u7684\u601d\u60f3\u3002
    • \u54c8\u5e0c\u8868\uff1a\u867d\u7136\u54c8\u5e0c\u8868\u5e76\u4e0d\u76f4\u63a5\u5e94\u7528\u5206\u6cbb\uff0c\u4f46\u67d0\u4e9b\u54c8\u5e0c\u51b2\u7a81\u89e3\u51b3\u65b9\u6848\u95f4\u63a5\u5e94\u7528\u4e86\u5206\u6cbb\u7b56\u7565\uff0c\u4f8b\u5982\uff0c\u94fe\u5f0f\u5730\u5740\u4e2d\u7684\u957f\u94fe\u8868\u4f1a\u88ab\u8f6c\u5316\u4e3a\u7ea2\u9ed1\u6811\uff0c\u4ee5\u63d0\u5347\u67e5\u8be2\u6548\u7387\u3002

    \u53ef\u4ee5\u770b\u51fa\uff0c\u5206\u6cbb\u662f\u4e00\u79cd\u201c\u6da6\u7269\u7ec6\u65e0\u58f0\u201d\u7684\u7b97\u6cd5\u601d\u60f3\uff0c\u9690\u542b\u5728\u5404\u79cd\u7b97\u6cd5\u4e0e\u6570\u636e\u7ed3\u6784\u4e4b\u4e2d\u3002

    "},{"location":"chapter_divide_and_conquer/hanota_problem/","title":"12.4 \u00a0 \u6c49\u8bfa\u5854\u95ee\u9898","text":"

    \u5728\u5f52\u5e76\u6392\u5e8f\u548c\u6784\u5efa\u4e8c\u53c9\u6811\u4e2d\uff0c\u6211\u4eec\u90fd\u662f\u5c06\u539f\u95ee\u9898\u5206\u89e3\u4e3a\u4e24\u4e2a\u89c4\u6a21\u4e3a\u539f\u95ee\u9898\u4e00\u534a\u7684\u5b50\u95ee\u9898\u3002\u7136\u800c\u5bf9\u4e8e\u6c49\u8bfa\u5854\u95ee\u9898\uff0c\u6211\u4eec\u91c7\u7528\u4e0d\u540c\u7684\u5206\u89e3\u7b56\u7565\u3002

    Question

    \u7ed9\u5b9a\u4e09\u6839\u67f1\u5b50\uff0c\u8bb0\u4e3a A\u3001B \u548c C \u3002\u8d77\u59cb\u72b6\u6001\u4e0b\uff0c\u67f1\u5b50 A \u4e0a\u5957\u7740 \\(n\\) \u4e2a\u5706\u76d8\uff0c\u5b83\u4eec\u4ece\u4e0a\u5230\u4e0b\u6309\u7167\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u6392\u5217\u3002\u6211\u4eec\u7684\u4efb\u52a1\u662f\u8981\u628a\u8fd9 \\(n\\) \u4e2a\u5706\u76d8\u79fb\u5230\u67f1\u5b50 C \u4e0a\uff0c\u5e76\u4fdd\u6301\u5b83\u4eec\u7684\u539f\u6709\u987a\u5e8f\u4e0d\u53d8\uff08\u5982\u56fe 12-10 \u6240\u793a\uff09\u3002\u5728\u79fb\u52a8\u5706\u76d8\u7684\u8fc7\u7a0b\u4e2d\uff0c\u9700\u8981\u9075\u5b88\u4ee5\u4e0b\u89c4\u5219\u3002

    1. \u5706\u76d8\u53ea\u80fd\u4ece\u4e00\u6839\u67f1\u5b50\u9876\u90e8\u62ff\u51fa\uff0c\u4ece\u53e6\u4e00\u6839\u67f1\u5b50\u9876\u90e8\u653e\u5165\u3002
    2. \u6bcf\u6b21\u53ea\u80fd\u79fb\u52a8\u4e00\u4e2a\u5706\u76d8\u3002
    3. \u5c0f\u5706\u76d8\u5fc5\u987b\u65f6\u523b\u4f4d\u4e8e\u5927\u5706\u76d8\u4e4b\u4e0a\u3002

    \u56fe 12-10 \u00a0 \u6c49\u8bfa\u5854\u95ee\u9898\u793a\u4f8b

    \u6211\u4eec\u5c06\u89c4\u6a21\u4e3a \\(i\\) \u7684\u6c49\u8bfa\u5854\u95ee\u9898\u8bb0\u4f5c \\(f(i)\\) \u3002\u4f8b\u5982 \\(f(3)\\) \u4ee3\u8868\u5c06 \\(3\\) \u4e2a\u5706\u76d8\u4ece A \u79fb\u52a8\u81f3 C \u7684\u6c49\u8bfa\u5854\u95ee\u9898\u3002

    "},{"location":"chapter_divide_and_conquer/hanota_problem/#1","title":"1. \u00a0 \u8003\u8651\u57fa\u672c\u60c5\u51b5","text":"

    \u5982\u56fe 12-11 \u6240\u793a\uff0c\u5bf9\u4e8e\u95ee\u9898 \\(f(1)\\) \uff0c\u5373\u5f53\u53ea\u6709\u4e00\u4e2a\u5706\u76d8\u65f6\uff0c\u6211\u4eec\u5c06\u5b83\u76f4\u63a5\u4ece A \u79fb\u52a8\u81f3 C \u5373\u53ef\u3002

    <1><2>

    \u56fe 12-11 \u00a0 \u89c4\u6a21\u4e3a 1 \u7684\u95ee\u9898\u7684\u89e3

    \u5982\u56fe 12-12 \u6240\u793a\uff0c\u5bf9\u4e8e\u95ee\u9898 \\(f(2)\\) \uff0c\u5373\u5f53\u6709\u4e24\u4e2a\u5706\u76d8\u65f6\uff0c\u7531\u4e8e\u8981\u65f6\u523b\u6ee1\u8db3\u5c0f\u5706\u76d8\u5728\u5927\u5706\u76d8\u4e4b\u4e0a\uff0c\u56e0\u6b64\u9700\u8981\u501f\u52a9 B \u6765\u5b8c\u6210\u79fb\u52a8\u3002

    1. \u5148\u5c06\u4e0a\u9762\u7684\u5c0f\u5706\u76d8\u4ece A \u79fb\u81f3 B \u3002
    2. \u518d\u5c06\u5927\u5706\u76d8\u4ece A \u79fb\u81f3 C \u3002
    3. \u6700\u540e\u5c06\u5c0f\u5706\u76d8\u4ece B \u79fb\u81f3 C \u3002
    <1><2><3><4>

    \u56fe 12-12 \u00a0 \u89c4\u6a21\u4e3a 2 \u7684\u95ee\u9898\u7684\u89e3

    \u89e3\u51b3\u95ee\u9898 \\(f(2)\\) \u7684\u8fc7\u7a0b\u53ef\u603b\u7ed3\u4e3a\uff1a\u5c06\u4e24\u4e2a\u5706\u76d8\u501f\u52a9 B \u4ece A \u79fb\u81f3 C \u3002\u5176\u4e2d\uff0cC \u79f0\u4e3a\u76ee\u6807\u67f1\u3001B \u79f0\u4e3a\u7f13\u51b2\u67f1\u3002

    "},{"location":"chapter_divide_and_conquer/hanota_problem/#2","title":"2. \u00a0 \u5b50\u95ee\u9898\u5206\u89e3","text":"

    \u5bf9\u4e8e\u95ee\u9898 \\(f(3)\\) \uff0c\u5373\u5f53\u6709\u4e09\u4e2a\u5706\u76d8\u65f6\uff0c\u60c5\u51b5\u53d8\u5f97\u7a0d\u5fae\u590d\u6742\u4e86\u4e00\u4e9b\u3002

    \u56e0\u4e3a\u5df2\u77e5 \\(f(1)\\) \u548c \\(f(2)\\) \u7684\u89e3\uff0c\u6240\u4ee5\u6211\u4eec\u53ef\u4ece\u5206\u6cbb\u89d2\u5ea6\u601d\u8003\uff0c\u5c06 A \u9876\u90e8\u7684\u4e24\u4e2a\u5706\u76d8\u770b\u4f5c\u4e00\u4e2a\u6574\u4f53\uff0c\u6267\u884c\u56fe 12-13 \u6240\u793a\u7684\u6b65\u9aa4\u3002\u8fd9\u6837\u4e09\u4e2a\u5706\u76d8\u5c31\u88ab\u987a\u5229\u5730\u4ece A \u79fb\u81f3 C \u4e86\u3002

    1. \u4ee4 B \u4e3a\u76ee\u6807\u67f1\u3001C \u4e3a\u7f13\u51b2\u67f1\uff0c\u5c06\u4e24\u4e2a\u5706\u76d8\u4ece A \u79fb\u81f3 B \u3002
    2. \u5c06 A \u4e2d\u5269\u4f59\u7684\u4e00\u4e2a\u5706\u76d8\u4ece A \u76f4\u63a5\u79fb\u52a8\u81f3 C \u3002
    3. \u4ee4 C \u4e3a\u76ee\u6807\u67f1\u3001A \u4e3a\u7f13\u51b2\u67f1\uff0c\u5c06\u4e24\u4e2a\u5706\u76d8\u4ece B \u79fb\u81f3 C \u3002
    <1><2><3><4>

    \u56fe 12-13 \u00a0 \u89c4\u6a21\u4e3a 3 \u7684\u95ee\u9898\u7684\u89e3

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u6211\u4eec\u5c06\u95ee\u9898 \\(f(3)\\) \u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u95ee\u9898 \\(f(2)\\) \u548c\u4e00\u4e2a\u5b50\u95ee\u9898 \\(f(1)\\) \u3002\u6309\u987a\u5e8f\u89e3\u51b3\u8fd9\u4e09\u4e2a\u5b50\u95ee\u9898\u4e4b\u540e\uff0c\u539f\u95ee\u9898\u968f\u4e4b\u5f97\u5230\u89e3\u51b3\u3002\u8fd9\u8bf4\u660e\u5b50\u95ee\u9898\u662f\u72ec\u7acb\u7684\uff0c\u800c\u4e14\u89e3\u53ef\u4ee5\u5408\u5e76\u3002

    \u81f3\u6b64\uff0c\u6211\u4eec\u53ef\u603b\u7ed3\u51fa\u56fe 12-14 \u6240\u793a\u7684\u89e3\u51b3\u6c49\u8bfa\u5854\u95ee\u9898\u7684\u5206\u6cbb\u7b56\u7565\uff1a\u5c06\u539f\u95ee\u9898 \\(f(n)\\) \u5212\u5206\u4e3a\u4e24\u4e2a\u5b50\u95ee\u9898 \\(f(n-1)\\) \u548c\u4e00\u4e2a\u5b50\u95ee\u9898 \\(f(1)\\) \uff0c\u5e76\u6309\u7167\u4ee5\u4e0b\u987a\u5e8f\u89e3\u51b3\u8fd9\u4e09\u4e2a\u5b50\u95ee\u9898\u3002

    1. \u5c06 \\(n-1\\) \u4e2a\u5706\u76d8\u501f\u52a9 C \u4ece A \u79fb\u81f3 B \u3002
    2. \u5c06\u5269\u4f59 \\(1\\) \u4e2a\u5706\u76d8\u4ece A \u76f4\u63a5\u79fb\u81f3 C \u3002
    3. \u5c06 \\(n-1\\) \u4e2a\u5706\u76d8\u501f\u52a9 A \u4ece B \u79fb\u81f3 C \u3002

    \u5bf9\u4e8e\u8fd9\u4e24\u4e2a\u5b50\u95ee\u9898 \\(f(n-1)\\) \uff0c\u53ef\u4ee5\u901a\u8fc7\u76f8\u540c\u7684\u65b9\u5f0f\u8fdb\u884c\u9012\u5f52\u5212\u5206\uff0c\u76f4\u81f3\u8fbe\u5230\u6700\u5c0f\u5b50\u95ee\u9898 \\(f(1)\\) \u3002\u800c \\(f(1)\\) \u7684\u89e3\u662f\u5df2\u77e5\u7684\uff0c\u53ea\u9700\u4e00\u6b21\u79fb\u52a8\u64cd\u4f5c\u5373\u53ef\u3002

    \u56fe 12-14 \u00a0 \u89e3\u51b3\u6c49\u8bfa\u5854\u95ee\u9898\u7684\u5206\u6cbb\u7b56\u7565

    "},{"location":"chapter_divide_and_conquer/hanota_problem/#3","title":"3. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5728\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u58f0\u660e\u4e00\u4e2a\u9012\u5f52\u51fd\u6570 dfs(i, src, buf, tar) \uff0c\u5b83\u7684\u4f5c\u7528\u662f\u5c06\u67f1 src \u9876\u90e8\u7684 \\(i\\) \u4e2a\u5706\u76d8\u501f\u52a9\u7f13\u51b2\u67f1 buf \u79fb\u52a8\u81f3\u76ee\u6807\u67f1 tar \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hanota.py
    def move(src: list[int], tar: list[int]):\n    \"\"\"\u79fb\u52a8\u4e00\u4e2a\u5706\u76d8\"\"\"\n    # \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    pan = src.pop()\n    # \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.append(pan)\n\ndef dfs(i: int, src: list[int], buf: list[int], tar: list[int]):\n    \"\"\"\u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i)\"\"\"\n    # \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if i == 1:\n        move(src, tar)\n        return\n    # \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf)\n    # \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar)\n    # \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar)\n\ndef solve_hanota(A: list[int], B: list[int], C: list[int]):\n    \"\"\"\u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898\"\"\"\n    n = len(A)\n    # \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C)\n
    hanota.cpp
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid move(vector<int> &src, vector<int> &tar) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    int pan = src.back();\n    src.pop_back();\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.push_back(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid dfs(int i, vector<int> &src, vector<int> &buf, vector<int> &tar) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid solveHanota(vector<int> &A, vector<int> &B, vector<int> &C) {\n    int n = A.size();\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.java
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid move(List<Integer> src, List<Integer> tar) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    Integer pan = src.remove(src.size() - 1);\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.add(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid dfs(int i, List<Integer> src, List<Integer> buf, List<Integer> tar) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid solveHanota(List<Integer> A, List<Integer> B, List<Integer> C) {\n    int n = A.size();\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.cs
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid Move(List<int> src, List<int> tar) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    int pan = src[^1];\n    src.RemoveAt(src.Count - 1);\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.Add(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid DFS(int i, List<int> src, List<int> buf, List<int> tar) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        Move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    DFS(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    Move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    DFS(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid SolveHanota(List<int> A, List<int> B, List<int> C) {\n    int n = A.Count;\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    DFS(n, A, B, C);\n}\n
    hanota.go
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfunc move(src, tar *list.List) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    pan := src.Back()\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.PushBack(pan.Value)\n    // \u79fb\u9664 src \u9876\u90e8\u5706\u76d8\n    src.Remove(pan)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfunc dfsHanota(i int, src, buf, tar *list.List) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if i == 1 {\n        move(src, tar)\n        return\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfsHanota(i-1, src, tar, buf)\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar)\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfsHanota(i-1, buf, src, tar)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfunc solveHanota(A, B, C *list.List) {\n    n := A.Len()\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfsHanota(n, A, B, C)\n}\n
    hanota.swift
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfunc move(src: inout [Int], tar: inout [Int]) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    let pan = src.popLast()!\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.append(pan)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfunc dfs(i: Int, src: inout [Int], buf: inout [Int], tar: inout [Int]) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if i == 1 {\n        move(src: &src, tar: &tar)\n        return\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i: i - 1, src: &src, buf: &tar, tar: &buf)\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src: &src, tar: &tar)\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i: i - 1, src: &buf, buf: &src, tar: &tar)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfunc solveHanota(A: inout [Int], B: inout [Int], C: inout [Int]) {\n    let n = A.count\n    // \u5217\u8868\u5c3e\u90e8\u662f\u67f1\u5b50\u9876\u90e8\n    // \u5c06 src \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(i: n, src: &A, buf: &B, tar: &C)\n}\n
    hanota.js
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfunction move(src, tar) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    const pan = src.pop();\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.push(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfunction dfs(i, src, buf, tar) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfunction solveHanota(A, B, C) {\n    const n = A.length;\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.ts
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfunction move(src: number[], tar: number[]): void {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    const pan = src.pop();\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.push(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfunction dfs(i: number, src: number[], buf: number[], tar: number[]): void {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i === 1) {\n        move(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfunction solveHanota(A: number[], B: number[], C: number[]): void {\n    const n = A.length;\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.dart
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid move(List<int> src, List<int> tar) {\n  // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n  int pan = src.removeLast();\n  // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n  tar.add(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid dfs(int i, List<int> src, List<int> buf, List<int> tar) {\n  // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n  if (i == 1) {\n    move(src, tar);\n    return;\n  }\n  // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n  dfs(i - 1, src, tar, buf);\n  // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n  move(src, tar);\n  // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n  dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid solveHanota(List<int> A, List<int> B, List<int> C) {\n  int n = A.length;\n  // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n  dfs(n, A, B, C);\n}\n
    hanota.rs
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfn move_pan(src: &mut Vec<i32>, tar: &mut Vec<i32>) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    let pan = src.remove(src.len() - 1);\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.push(pan);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfn dfs(i: i32, src: &mut Vec<i32>, buf: &mut Vec<i32>, tar: &mut Vec<i32>) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if i == 1 {\n        move_pan(src, tar);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move_pan(src, tar);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfn solve_hanota(A: &mut Vec<i32>, B: &mut Vec<i32>, C: &mut Vec<i32>) {\n    let n = A.len() as i32;\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C);\n}\n
    hanota.c
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nvoid move(int *src, int *srcSize, int *tar, int *tarSize) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    int pan = src[*srcSize - 1];\n    src[*srcSize - 1] = 0;\n    (*srcSize)--;\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar[*tarSize] = pan;\n    (*tarSize)++;\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nvoid dfs(int i, int *src, int *srcSize, int *buf, int *bufSize, int *tar, int *tarSize) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        move(src, srcSize, tar, tarSize);\n        return;\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, srcSize, tar, tarSize, buf, bufSize);\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, srcSize, tar, tarSize);\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, bufSize, src, srcSize, tar, tarSize);\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nvoid solveHanota(int *A, int *ASize, int *B, int *BSize, int *C, int *CSize) {\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(*ASize, A, ASize, B, BSize, C, CSize);\n}\n
    hanota.kt
    /* \u79fb\u52a8\u4e00\u4e2a\u5706\u76d8 */\nfun move(src: MutableList<Int>, tar: MutableList<Int>) {\n    // \u4ece src \u9876\u90e8\u62ff\u51fa\u4e00\u4e2a\u5706\u76d8\n    val pan: Int = src.removeAt(src.size - 1)\n    // \u5c06\u5706\u76d8\u653e\u5165 tar \u9876\u90e8\n    tar.add(pan)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 f(i) */\nfun dfs(i: Int, src: MutableList<Int>, buf: MutableList<Int>, tar: MutableList<Int>) {\n    // \u82e5 src \u53ea\u5269\u4e0b\u4e00\u4e2a\u5706\u76d8\uff0c\u5219\u76f4\u63a5\u5c06\u5176\u79fb\u5230 tar\n    if (i == 1) {\n        move(src, tar)\n        return\n    }\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 src \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 tar \u79fb\u5230 buf\n    dfs(i - 1, src, tar, buf)\n    // \u5b50\u95ee\u9898 f(1) \uff1a\u5c06 src \u5269\u4f59\u4e00\u4e2a\u5706\u76d8\u79fb\u5230 tar\n    move(src, tar)\n    // \u5b50\u95ee\u9898 f(i-1) \uff1a\u5c06 buf \u9876\u90e8 i-1 \u4e2a\u5706\u76d8\u501f\u52a9 src \u79fb\u5230 tar\n    dfs(i - 1, buf, src, tar)\n}\n\n/* \u6c42\u89e3\u6c49\u8bfa\u5854\u95ee\u9898 */\nfun solveHanota(A: MutableList<Int>, B: MutableList<Int>, C: MutableList<Int>) {\n    val n = A.size\n    // \u5c06 A \u9876\u90e8 n \u4e2a\u5706\u76d8\u501f\u52a9 B \u79fb\u5230 C\n    dfs(n, A, B, C)\n}\n
    hanota.rb
    [class]{}-[func]{move}\n\n[class]{}-[func]{dfs}\n\n[class]{}-[func]{solve_hanota}\n
    hanota.zig
    [class]{}-[func]{move}\n\n[class]{}-[func]{dfs}\n\n[class]{}-[func]{solveHanota}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 12-15 \u6240\u793a\uff0c\u6c49\u8bfa\u5854\u95ee\u9898\u5f62\u6210\u4e00\u68f5\u9ad8\u5ea6\u4e3a \\(n\\) \u7684\u9012\u5f52\u6811\uff0c\u6bcf\u4e2a\u8282\u70b9\u4ee3\u8868\u4e00\u4e2a\u5b50\u95ee\u9898\uff0c\u5bf9\u5e94\u4e00\u4e2a\u5f00\u542f\u7684 dfs() \u51fd\u6570\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    \u56fe 12-15 \u00a0 \u6c49\u8bfa\u5854\u95ee\u9898\u7684\u9012\u5f52\u6811

    Quote

    \u6c49\u8bfa\u5854\u95ee\u9898\u6e90\u81ea\u4e00\u4e2a\u53e4\u8001\u7684\u4f20\u8bf4\u3002\u5728\u53e4\u5370\u5ea6\u7684\u4e00\u4e2a\u5bfa\u5e99\u91cc\uff0c\u50e7\u4fa3\u4eec\u6709\u4e09\u6839\u9ad8\u5927\u7684\u94bb\u77f3\u67f1\u5b50\uff0c\u4ee5\u53ca \\(64\\) \u4e2a\u5927\u5c0f\u4e0d\u4e00\u7684\u91d1\u5706\u76d8\u3002\u50e7\u4fa3\u4eec\u4e0d\u65ad\u5730\u79fb\u52a8\u5706\u76d8\uff0c\u4ed6\u4eec\u76f8\u4fe1\u5728\u6700\u540e\u4e00\u4e2a\u5706\u76d8\u88ab\u6b63\u786e\u653e\u7f6e\u7684\u90a3\u4e00\u523b\uff0c\u8fd9\u4e2a\u4e16\u754c\u5c31\u4f1a\u7ed3\u675f\u3002

    \u7136\u800c\uff0c\u5373\u4f7f\u50e7\u4fa3\u4eec\u6bcf\u79d2\u949f\u79fb\u52a8\u4e00\u6b21\uff0c\u603b\u5171\u9700\u8981\u5927\u7ea6 \\(2^{64} \\approx 1.84\u00d710^{19}\\) \u79d2\uff0c\u5408\u7ea6 \\(5850\\) \u4ebf\u5e74\uff0c\u8fdc\u8fdc\u8d85\u8fc7\u4e86\u73b0\u5728\u5bf9\u5b87\u5b99\u5e74\u9f84\u7684\u4f30\u8ba1\u3002\u6240\u4ee5\uff0c\u5018\u82e5\u8fd9\u4e2a\u4f20\u8bf4\u662f\u771f\u7684\uff0c\u6211\u4eec\u5e94\u8be5\u4e0d\u9700\u8981\u62c5\u5fc3\u4e16\u754c\u672b\u65e5\u7684\u5230\u6765\u3002

    "},{"location":"chapter_divide_and_conquer/summary/","title":"12.5 \u00a0 \u5c0f\u7ed3","text":"
    • \u5206\u6cbb\u662f\u4e00\u79cd\u5e38\u89c1\u7684\u7b97\u6cd5\u8bbe\u8ba1\u7b56\u7565\uff0c\u5305\u62ec\u5206\uff08\u5212\u5206\uff09\u548c\u6cbb\uff08\u5408\u5e76\uff09\u4e24\u4e2a\u9636\u6bb5\uff0c\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u5b9e\u73b0\u3002
    • \u5224\u65ad\u662f\u5426\u662f\u5206\u6cbb\u7b97\u6cd5\u95ee\u9898\u7684\u4f9d\u636e\u5305\u62ec\uff1a\u95ee\u9898\u80fd\u5426\u5206\u89e3\u3001\u5b50\u95ee\u9898\u662f\u5426\u72ec\u7acb\u3001\u5b50\u95ee\u9898\u80fd\u5426\u5408\u5e76\u3002
    • \u5f52\u5e76\u6392\u5e8f\u662f\u5206\u6cbb\u7b56\u7565\u7684\u5178\u578b\u5e94\u7528\uff0c\u5176\u9012\u5f52\u5730\u5c06\u6570\u7ec4\u5212\u5206\u4e3a\u7b49\u957f\u7684\u4e24\u4e2a\u5b50\u6570\u7ec4\uff0c\u76f4\u5230\u53ea\u5269\u4e00\u4e2a\u5143\u7d20\u65f6\u5f00\u59cb\u9010\u5c42\u5408\u5e76\uff0c\u4ece\u800c\u5b8c\u6210\u6392\u5e8f\u3002
    • \u5f15\u5165\u5206\u6cbb\u7b56\u7565\u5f80\u5f80\u53ef\u4ee5\u63d0\u5347\u7b97\u6cd5\u6548\u7387\u3002\u4e00\u65b9\u9762\uff0c\u5206\u6cbb\u7b56\u7565\u51cf\u5c11\u4e86\u64cd\u4f5c\u6570\u91cf\uff1b\u53e6\u4e00\u65b9\u9762\uff0c\u5206\u6cbb\u540e\u6709\u5229\u4e8e\u7cfb\u7edf\u7684\u5e76\u884c\u4f18\u5316\u3002
    • \u5206\u6cbb\u65e2\u53ef\u4ee5\u89e3\u51b3\u8bb8\u591a\u7b97\u6cd5\u95ee\u9898\uff0c\u4e5f\u5e7f\u6cdb\u5e94\u7528\u4e8e\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u8bbe\u8ba1\u4e2d\uff0c\u5904\u5904\u53ef\u89c1\u5176\u8eab\u5f71\u3002
    • \u76f8\u8f83\u4e8e\u66b4\u529b\u641c\u7d22\uff0c\u81ea\u9002\u5e94\u641c\u7d22\u6548\u7387\u66f4\u9ad8\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \u7684\u641c\u7d22\u7b97\u6cd5\u901a\u5e38\u662f\u57fa\u4e8e\u5206\u6cbb\u7b56\u7565\u5b9e\u73b0\u7684\u3002
    • \u4e8c\u5206\u67e5\u627e\u662f\u5206\u6cbb\u7b56\u7565\u7684\u53e6\u4e00\u4e2a\u5178\u578b\u5e94\u7528\uff0c\u5b83\u4e0d\u5305\u542b\u5c06\u5b50\u95ee\u9898\u7684\u89e3\u8fdb\u884c\u5408\u5e76\u7684\u6b65\u9aa4\u3002\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u9012\u5f52\u5206\u6cbb\u5b9e\u73b0\u4e8c\u5206\u67e5\u627e\u3002
    • \u5728\u6784\u5efa\u4e8c\u53c9\u6811\u7684\u95ee\u9898\u4e2d\uff0c\u6784\u5efa\u6811\uff08\u539f\u95ee\u9898\uff09\u53ef\u4ee5\u5212\u5206\u4e3a\u6784\u5efa\u5de6\u5b50\u6811\u548c\u53f3\u5b50\u6811\uff08\u5b50\u95ee\u9898\uff09\uff0c\u8fd9\u53ef\u4ee5\u901a\u8fc7\u5212\u5206\u524d\u5e8f\u904d\u5386\u548c\u4e2d\u5e8f\u904d\u5386\u7684\u7d22\u5f15\u533a\u95f4\u6765\u5b9e\u73b0\u3002
    • \u5728\u6c49\u8bfa\u5854\u95ee\u9898\u4e2d\uff0c\u4e00\u4e2a\u89c4\u6a21\u4e3a \\(n\\) \u7684\u95ee\u9898\u53ef\u4ee5\u5212\u5206\u4e3a\u4e24\u4e2a\u89c4\u6a21\u4e3a \\(n-1\\) \u7684\u5b50\u95ee\u9898\u548c\u4e00\u4e2a\u89c4\u6a21\u4e3a \\(1\\) \u7684\u5b50\u95ee\u9898\u3002\u6309\u987a\u5e8f\u89e3\u51b3\u8fd9\u4e09\u4e2a\u5b50\u95ee\u9898\u540e\uff0c\u539f\u95ee\u9898\u968f\u4e4b\u5f97\u5230\u89e3\u51b3\u3002
    "},{"location":"chapter_dynamic_programming/","title":"\u7b2c 14 \u7ae0 \u00a0 \u52a8\u6001\u89c4\u5212","text":"

    Abstract

    \u5c0f\u6eaa\u6c47\u5165\u6cb3\u6d41\uff0c\u6c5f\u6cb3\u6c47\u5165\u5927\u6d77\u3002

    \u52a8\u6001\u89c4\u5212\u5c06\u5c0f\u95ee\u9898\u7684\u89e3\u6c47\u96c6\u6210\u5927\u95ee\u9898\u7684\u7b54\u6848\uff0c\u4e00\u6b65\u6b65\u5f15\u9886\u6211\u4eec\u8d70\u5411\u89e3\u51b3\u95ee\u9898\u7684\u5f7c\u5cb8\u3002

    "},{"location":"chapter_dynamic_programming/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 14.1 \u00a0 \u521d\u63a2\u52a8\u6001\u89c4\u5212
    • 14.2 \u00a0 DP \u95ee\u9898\u7279\u6027
    • 14.3 \u00a0 DP \u89e3\u9898\u601d\u8def
    • 14.4 \u00a0 0-1 \u80cc\u5305\u95ee\u9898
    • 14.5 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898
    • 14.6 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898
    • 14.7 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_dynamic_programming/dp_problem_features/","title":"14.2 \u00a0 \u52a8\u6001\u89c4\u5212\u95ee\u9898\u7279\u6027","text":"

    \u5728\u4e0a\u4e00\u8282\u4e2d\uff0c\u6211\u4eec\u5b66\u4e60\u4e86\u52a8\u6001\u89c4\u5212\u662f\u5982\u4f55\u901a\u8fc7\u5b50\u95ee\u9898\u5206\u89e3\u6765\u6c42\u89e3\u539f\u95ee\u9898\u7684\u3002\u5b9e\u9645\u4e0a\uff0c\u5b50\u95ee\u9898\u5206\u89e3\u662f\u4e00\u79cd\u901a\u7528\u7684\u7b97\u6cd5\u601d\u8def\uff0c\u5728\u5206\u6cbb\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u4e2d\u7684\u4fa7\u91cd\u70b9\u4e0d\u540c\u3002

    • \u5206\u6cbb\u7b97\u6cd5\u9012\u5f52\u5730\u5c06\u539f\u95ee\u9898\u5212\u5206\u4e3a\u591a\u4e2a\u76f8\u4e92\u72ec\u7acb\u7684\u5b50\u95ee\u9898\uff0c\u76f4\u81f3\u6700\u5c0f\u5b50\u95ee\u9898\uff0c\u5e76\u5728\u56de\u6eaf\u4e2d\u5408\u5e76\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u6700\u7ec8\u5f97\u5230\u539f\u95ee\u9898\u7684\u89e3\u3002
    • \u52a8\u6001\u89c4\u5212\u4e5f\u5bf9\u95ee\u9898\u8fdb\u884c\u9012\u5f52\u5206\u89e3\uff0c\u4f46\u4e0e\u5206\u6cbb\u7b97\u6cd5\u7684\u4e3b\u8981\u533a\u522b\u662f\uff0c\u52a8\u6001\u89c4\u5212\u4e2d\u7684\u5b50\u95ee\u9898\u662f\u76f8\u4e92\u4f9d\u8d56\u7684\uff0c\u5728\u5206\u89e3\u8fc7\u7a0b\u4e2d\u4f1a\u51fa\u73b0\u8bb8\u591a\u91cd\u53e0\u5b50\u95ee\u9898\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\u524d\u7684\u5b50\u5e8f\u5217\u770b\u4f5c\u4e00\u4e2a\u5b50\u95ee\u9898\u3002

    \u5b9e\u9645\u4e0a\uff0c\u52a8\u6001\u89c4\u5212\u5e38\u7528\u6765\u6c42\u89e3\u6700\u4f18\u5316\u95ee\u9898\uff0c\u5b83\u4eec\u4e0d\u4ec5\u5305\u542b\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\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/#1421","title":"14.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\uff08\u8d77\u59cb\u70b9\uff09\u3002\u8bf7\u8ba1\u7b97\u6700\u5c11\u9700\u8981\u4ed8\u51fa\u591a\u5c11\u4ee3\u4ef7\u624d\u80fd\u5230\u8fbe\u9876\u90e8\uff1f

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

    \u56fe 14-6 \u00a0 \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\uff1a

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

    \u8fd9\u4fbf\u53ef\u4ee5\u5f15\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\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

    \u672c\u9898\u663e\u7136\u5177\u6709\u6700\u4f18\u5b50\u7ed3\u6784\uff1a\u6211\u4eec\u4ece\u4e24\u4e2a\u5b50\u95ee\u9898\u6700\u4f18\u89e3 \\(dp[i-1]\\) \u548c \\(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

    \u90a3\u4e48\uff0c\u4e0a\u4e00\u8282\u7684\u722c\u697c\u68af\u9898\u76ee\u6709\u6ca1\u6709\u6700\u4f18\u5b50\u7ed3\u6784\u5462\uff1f\u5b83\u7684\u76ee\u6807\u662f\u6c42\u89e3\u65b9\u6848\u6570\u91cf\uff0c\u770b\u4f3c\u662f\u4e00\u4e2a\u8ba1\u6570\u95ee\u9898\uff0c\u4f46\u5982\u679c\u6362\u4e00\u79cd\u95ee\u6cd5\uff1a\u201c\u6c42\u89e3\u6700\u5927\u65b9\u6848\u6570\u91cf\u201d\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\u89e3\u91ca\u65b9\u5f0f\u6bd4\u8f83\u7075\u6d3b\uff0c\u5728\u4e0d\u540c\u95ee\u9898\u4e2d\u4f1a\u6709\u4e0d\u540c\u7684\u542b\u4e49\u3002

    \u6839\u636e\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff0c\u4ee5\u53ca\u521d\u59cb\u72b6\u6001 \\(dp[1] = cost[1]\\) \u548c \\(dp[2] = cost[2]\\) \uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5f97\u5230\u52a8\u6001\u89c4\u5212\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    # \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp = [0] * (n + 1)\n    # \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[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\n    for i in range(3, n + 1):\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    return dp[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) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    vector<int> dp(n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.java
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[] dp = new int[n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint MinCostClimbingStairsDP(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[] dp = new int[n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.go
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc minCostClimbingStairsDP(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a < b {\n            return a\n        }\n        return b\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp := make([]int, n+1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i := 3; i <= n; i++ {\n        dp[i] = min(dp[i-1], dp[i-2]) + cost[i]\n    }\n    return dp[n]\n}\n
    min_cost_climbing_stairs_dp.swift
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc minCostClimbingStairsDP(cost: [Int]) -> Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = Array(repeating: 0, count: n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3 ... n {\n        dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]\n    }\n    return dp[n]\n}\n
    min_cost_climbing_stairs_dp.js
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction minCostClimbingStairsDP(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = new Array(n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.ts
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction minCostClimbingStairsDP(cost: Array<number>): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = new Array(n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    min_cost_climbing_stairs_dp.dart
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(List<int> cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n  List<int> dp = List.filled(n + 1, 0);\n  // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n  dp[1] = cost[1];\n  dp[2] = cost[2];\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n  for (int i = 3; i <= n; i++) {\n    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];\n  }\n  return dp[n];\n}\n
    min_cost_climbing_stairs_dp.rs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    let mut dp = vec![-1; n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3..=n {\n        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    dp[n]\n}\n
    min_cost_climbing_stairs_dp.c
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDP(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int *dp = calloc(n + 1, sizeof(int));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    int res = dp[n];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    min_cost_climbing_stairs_dp.kt
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212 */\nfun minCostClimbingStairsDP(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    val dp = IntArray(n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1]\n    dp[2] = cost[2]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (i in 3..n) {\n        dp[i] = (min(dp[i - 1].toDouble(), dp[i - 2].toDouble()) + cost[i]).toInt()\n    }\n    return dp[n]\n}\n
    min_cost_climbing_stairs_dp.rb
    [class]{}-[func]{min_cost_climbing_stairs_dp}\n
    min_cost_climbing_stairs_dp.zig
    // \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u52a8\u6001\u89c4\u5212\nfn minCostClimbingStairsDP(comptime cost: []i32) i32 {\n    comptime var n = cost.len - 1;\n    if (n == 1 or n == 2) {\n        return cost[n];\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = [_]i32{-1} ** (n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = cost[1];\n    dp[2] = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (3..n + 1) |i| {\n        dp[i] = @min(dp[i - 1], dp[i - 2]) + cost[i];\n    }\n    return dp[n];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-7 \u5c55\u793a\u4e86\u4ee5\u4e0a\u4ee3\u7801\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b\u3002

    \u56fe 14-7 \u00a0 \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u672c\u9898\u4e5f\u53ef\u4ee5\u8fdb\u884c\u7a7a\u95f4\u4f18\u5316\uff0c\u5c06\u4e00\u7ef4\u538b\u7f29\u81f3\u96f6\u7ef4\uff0c\u4f7f\u5f97\u7a7a\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n)\\) \u964d\u81f3 \\(O(1)\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(cost) - 1\n    if n == 1 or n == 2:\n        return cost[n]\n    a, b = cost[1], cost[2]\n    for i in range(3, n + 1):\n        a, b = b, min(a, b) + cost[i]\n    return b\n
    min_cost_climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(vector<int> &cost) {\n    int n = cost.size() - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.java
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint MinCostClimbingStairsDPComp(int[] cost) {\n    int n = cost.Length - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = Math.Min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.go
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc minCostClimbingStairsDPComp(cost []int) int {\n    n := len(cost) - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    min := func(a, b int) int {\n        if a < b {\n            return a\n        }\n        return b\n    }\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    a, b := 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\n    for i := 3; i <= n; i++ {\n        tmp := b\n        b = min(a, tmp) + cost[i]\n        a = tmp\n    }\n    return b\n}\n
    min_cost_climbing_stairs_dp.swift
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc minCostClimbingStairsDPComp(cost: [Int]) -> Int {\n    let n = cost.count - 1\n    if n == 1 || n == 2 {\n        return cost[n]\n    }\n    var (a, b) = (cost[1], cost[2])\n    for i in 3 ... n {\n        (a, b) = (b, min(a, b) + cost[i])\n    }\n    return b\n}\n
    min_cost_climbing_stairs_dp.js
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction minCostClimbingStairsDPComp(cost) {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i <= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.ts
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction minCostClimbingStairsDPComp(cost: Array<number>): number {\n    const n = cost.length - 1;\n    if (n === 1 || n === 2) {\n        return cost[n];\n    }\n    let a = cost[1],\n        b = cost[2];\n    for (let i = 3; i <= n; i++) {\n        const tmp = b;\n        b = Math.min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.dart
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(List<int> cost) {\n  int n = cost.length - 1;\n  if (n == 1 || n == 2) return cost[n];\n  int a = cost[1], b = cost[2];\n  for (int i = 3; i <= n; i++) {\n    int tmp = b;\n    b = min(a, tmp) + cost[i];\n    a = tmp;\n  }\n  return b;\n}\n
    min_cost_climbing_stairs_dp.rs
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {\n    let n = cost.len() - 1;\n    if n == 1 || n == 2 {\n        return cost[n];\n    };\n    let (mut a, mut b) = (cost[1], cost[2]);\n    for i in 3..=n {\n        let tmp = b;\n        b = cmp::min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    b\n}\n
    min_cost_climbing_stairs_dp.c
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minCostClimbingStairsDPComp(int cost[], int costSize) {\n    int n = costSize - 1;\n    if (n == 1 || n == 2)\n        return cost[n];\n    int a = cost[1], b = cost[2];\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = myMin(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    min_cost_climbing_stairs_dp.kt
    /* \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun minCostClimbingStairsDPComp(cost: IntArray): Int {\n    val n = cost.size - 1\n    if (n == 1 || n == 2) return cost[n]\n    var a = cost[1]\n    var b = cost[2]\n    for (i in 3..n) {\n        val tmp = b\n        b = (min(a.toDouble(), tmp.toDouble()) + cost[i]).toInt()\n        a = tmp\n    }\n    return b\n}\n
    min_cost_climbing_stairs_dp.rb
    [class]{}-[func]{min_cost_climbing_stairs_dp_comp}\n
    min_cost_climbing_stairs_dp.zig
    // \u722c\u697c\u68af\u6700\u5c0f\u4ee3\u4ef7\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn minCostClimbingStairsDPComp(cost: []i32) i32 {\n    var n = cost.len - 1;\n    if (n == 1 or n == 2) {\n        return cost[n];\n    }\n    var a = cost[1];\n    var b = cost[2];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (3..n + 1) |i| {\n        var tmp = b;\n        b = @min(a, tmp) + cost[i];\n        a = tmp;\n    }\n    return b;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/dp_problem_features/#1422","title":"14.2.2 \u00a0 \u65e0\u540e\u6548\u6027","text":"

    \u65e0\u540e\u6548\u6027\u662f\u52a8\u6001\u89c4\u5212\u80fd\u591f\u6709\u6548\u89e3\u51b3\u95ee\u9898\u7684\u91cd\u8981\u7279\u6027\u4e4b\u4e00\uff0c\u5176\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\u8fc7\u53bb\u7ecf\u5386\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\u987b\u8003\u8651\u72b6\u6001 \\(i\\) \u4e4b\u524d\u7684\u72b6\u6001\uff0c\u5b83\u4eec\u5bf9\u72b6\u6001 \\(i\\) \u7684\u672a\u6765\u6ca1\u6709\u5f71\u54cd\u3002

    \u7136\u800c\uff0c\u5982\u679c\u6211\u4eec\u7ed9\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\uff1f

    \u5982\u56fe 14-8 \u6240\u793a\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

    \u56fe 14-8 \u00a0 \u5e26\u7ea6\u675f\u722c\u5230\u7b2c 3 \u9636\u7684\u65b9\u6848\u6570\u91cf

    \u5728\u8be5\u95ee\u9898\u4e2d\uff0c\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\u8fd9\u610f\u5473\u7740\uff0c\u4e0b\u4e00\u6b65\u9009\u62e9\u4e0d\u80fd\u7531\u5f53\u524d\u72b6\u6001\uff08\u5f53\u524d\u6240\u5728\u697c\u68af\u9636\u6570\uff09\u72ec\u7acb\u51b3\u5b9a\uff0c\u8fd8\u548c\u524d\u4e00\u4e2a\u72b6\u6001\uff08\u4e0a\u4e00\u8f6e\u6240\u5728\u697c\u68af\u9636\u6570\uff09\u6709\u5173\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\u662f\u8df3 \\(1\\) \u9636\u4e0a\u6765\u7684\u201d\u65b9\u6848\uff0c\u800c\u4e3a\u4e86\u6ee1\u8db3\u7ea6\u675f\uff0c\u6211\u4eec\u5c31\u4e0d\u80fd\u5c06 \\(dp[i-1]\\) \u76f4\u63a5\u8ba1\u5165 \\(dp[i]\\) \u4e2d\u3002

    \u4e3a\u6b64\uff0c\u6211\u4eec\u9700\u8981\u6269\u5c55\u72b6\u6001\u5b9a\u4e49\uff1a\u72b6\u6001 \\([i, j]\\) \u8868\u793a\u5904\u5728\u7b2c \\(i\\) \u9636\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\u5224\u65ad\u5f53\u524d\u72b6\u6001\u662f\u4ece\u4f55\u800c\u6765\u7684\u3002

    • \u5f53\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(1\\) \u9636\u65f6\uff0c\u4e0a\u4e0a\u4e00\u8f6e\u53ea\u80fd\u9009\u62e9\u8df3 \\(2\\) \u9636\uff0c\u5373 \\(dp[i, 1]\\) \u53ea\u80fd\u4ece \\(dp[i-1, 2]\\) \u8f6c\u79fb\u8fc7\u6765\u3002
    • \u5f53\u4e0a\u4e00\u8f6e\u8df3\u4e86 \\(2\\) \u9636\u65f6\uff0c\u4e0a\u4e0a\u4e00\u8f6e\u53ef\u9009\u62e9\u8df3 \\(1\\) \u9636\u6216\u8df3 \\(2\\) \u9636\uff0c\u5373 \\(dp[i, 2]\\) \u53ef\u4ee5\u4ece \\(dp[i-2, 1]\\) \u6216 \\(dp[i-2, 2]\\) \u8f6c\u79fb\u8fc7\u6765\u3002

    \u5982\u56fe 14-9 \u6240\u793a\uff0c\u5728\u8be5\u5b9a\u4e49\u4e0b\uff0c\\(dp[i, j]\\) \u8868\u793a\u72b6\u6001 \\([i, j]\\) \u5bf9\u5e94\u7684\u65b9\u6848\u6570\u3002\u6b64\u65f6\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e3a\uff1a

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

    \u56fe 14-9 \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    if n == 1 or n == 2:\n        return 1\n    # \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp = [[0] * 3 for _ in range(n + 1)]\n    # \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1], dp[1][2] = 1, 0\n    dp[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\n    for i in range(3, n + 1):\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    return dp[n][1] + dp[n][2]\n
    climbing_stairs_constraint_dp.cpp
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    vector<vector<int>> dp(n + 1, vector<int>(3, 0));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.java
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[][] dp = new int[n + 1][3];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.cs
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint ClimbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[,] dp = new int[n + 1, 3];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1, 1] = 1;\n    dp[1, 2] = 0;\n    dp[2, 1] = 0;\n    dp[2, 2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i, 1] = dp[i - 1, 2];\n        dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];\n    }\n    return dp[n, 1] + dp[n, 2];\n}\n
    climbing_stairs_constraint_dp.go
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsConstraintDP(n int) int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp := make([][3]int, n+1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i := 3; i <= n; i++ {\n        dp[i][1] = dp[i-1][2]\n        dp[i][2] = dp[i-2][1] + dp[i-2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n
    climbing_stairs_constraint_dp.swift
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsConstraintDP(n: Int) -> Int {\n    if n == 1 || n == 2 {\n        return 1\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = Array(repeating: Array(repeating: 0, count: 3), count: n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3 ... n {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n
    climbing_stairs_constraint_dp.js
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsConstraintDP(n) {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = Array.from(new Array(n + 1), () => new Array(3));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.ts
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsConstraintDP(n: number): number {\n    if (n === 1 || n === 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = Array.from({ length: n + 1 }, () => new Array(3));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.dart
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\n  if (n == 1 || n == 2) {\n    return 1;\n  }\n  // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(3, 0));\n  // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n  dp[1][1] = 1;\n  dp[1][2] = 0;\n  dp[2][1] = 0;\n  dp[2][2] = 1;\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n  for (int i = 3; i <= n; i++) {\n    dp[i][1] = dp[i - 1][2];\n    dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n  }\n  return dp[n][1] + dp[n][2];\n}\n
    climbing_stairs_constraint_dp.rs
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfn climbing_stairs_constraint_dp(n: usize) -> i32 {\n    if n == 1 || n == 2 {\n        return 1;\n    };\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    let mut dp = vec![vec![-1; 3]; n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3..=n {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    dp[n][1] + dp[n][2]\n}\n
    climbing_stairs_constraint_dp.c
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsConstraintDP(int n) {\n    if (n == 1 || n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(3, sizeof(int));\n    }\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    int res = dp[n][1] + dp[n][2];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n
    climbing_stairs_constraint_dp.kt
    /* \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfun climbingStairsConstraintDP(n: Int): Int {\n    if (n == 1 || n == 2) {\n        return 1\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    val dp = Array(n + 1) { IntArray(3) }\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1\n    dp[1][2] = 0\n    dp[2][1] = 0\n    dp[2][2] = 1\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (i in 3..n) {\n        dp[i][1] = dp[i - 1][2]\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2]\n    }\n    return dp[n][1] + dp[n][2]\n}\n
    climbing_stairs_constraint_dp.rb
    [class]{}-[func]{climbing_stairs_constraint_dp}\n
    climbing_stairs_constraint_dp.zig
    // \u5e26\u7ea6\u675f\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\nfn climbingStairsConstraintDP(comptime n: usize) i32 {\n    if (n == 1 or n == 2) {\n        return 1;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = [_][3]i32{ [_]i32{ -1, -1, -1 } } ** (n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1][1] = 1;\n    dp[1][2] = 0;\n    dp[2][1] = 0;\n    dp[2][2] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (3..n + 1) |i| {\n        dp[i][1] = dp[i - 1][2];\n        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];\n    }\n    return dp[n][1] + dp[n][2];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

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

    \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\u5728\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\\)\u3001\\(3\\) \u9636\u4e0a\uff0c\u5219\u4e4b\u540e\u5c31\u4e0d\u80fd\u8df3\u5230\u7b2c \\(4\\)\u3001\\(6\\) \u9636\u4e0a\u3002\u8bf7\u95ee\u6709\u591a\u5c11\u79cd\u65b9\u6848\u53ef\u4ee5\u722c\u5230\u697c\u9876\uff1f

    \u5728\u8fd9\u4e2a\u95ee\u9898\u4e2d\uff0c\u4e0b\u6b21\u8df3\u8dc3\u4f9d\u8d56\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\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u590d\u6742\u7684\u7ec4\u5408\u4f18\u5316\u95ee\u9898\uff08\u4f8b\u5982\u65c5\u884c\u5546\u95ee\u9898\uff09\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\u5728\u6709\u9650\u65f6\u95f4\u5185\u5f97\u5230\u53ef\u7528\u7684\u5c40\u90e8\u6700\u4f18\u89e3\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/","title":"14.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\u3002

    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/#1431","title":"14.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\u9002\u5408\u7528\u52a8\u6001\u89c4\u5212\u6c42\u89e3\u3002\u7136\u800c\uff0c\u6211\u4eec\u5f88\u96be\u4ece\u95ee\u9898\u63cf\u8ff0\u4e2d\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\u52a8\u6001\u89c4\u5212\u95ee\u9898\u8fd8\u6709\u4e00\u4e9b\u5224\u65ad\u7684\u201c\u52a0\u5206\u9879\u201d\u3002

    • \u95ee\u9898\u5305\u542b\u6700\u5927\uff08\u5c0f\uff09\u6216\u6700\u591a\uff08\u5c11\uff09\u7b49\u6700\u4f18\u5316\u63cf\u8ff0\u3002
    • \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\u9012\u63a8\u5173\u7cfb\u3002

    \u76f8\u5e94\u5730\uff0c\u4e5f\u5b58\u5728\u4e00\u4e9b\u201c\u51cf\u5206\u9879\u201d\u3002

    • \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\u201d\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5047\u8bbe\u5b83\u662f\u4e00\u4e2a\u52a8\u6001\u89c4\u5212\u95ee\u9898\uff0c\u5e76\u5728\u6c42\u89e3\u8fc7\u7a0b\u4e2d\u9a8c\u8bc1\u5b83\u3002

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#1432","title":"14.3.2 \u00a0 \u95ee\u9898\u6c42\u89e3\u6b65\u9aa4","text":"

    \u52a8\u6001\u89c4\u5212\u7684\u89e3\u9898\u6d41\u7a0b\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\u201c\u6700\u5c0f\u8def\u5f84\u548c\u201d\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

    \u56fe 14-10 \u5c55\u793a\u4e86\u4e00\u4e2a\u4f8b\u5b50\uff0c\u7ed9\u5b9a\u7f51\u683c\u7684\u6700\u5c0f\u8def\u5f84\u548c\u4e3a \\(13\\) \u3002

    \u56fe 14-10 \u00a0 \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\u8d70\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\u56fe 14-11 \u6240\u793a\u7684\u4e8c\u7ef4 \\(dp\\) \u77e9\u9635\uff0c\u5176\u5c3a\u5bf8\u4e0e\u8f93\u5165\u7f51\u683c \\(grid\\) \u76f8\u540c\u3002

    \u56fe 14-11 \u00a0 \u72b6\u6001\u5b9a\u4e49\u4e0e dp \u8868

    Note

    \u52a8\u6001\u89c4\u5212\u548c\u56de\u6eaf\u8fc7\u7a0b\u53ef\u4ee5\u63cf\u8ff0\u4e3a\u4e00\u4e2a\u51b3\u7b56\u5e8f\u5217\uff0c\u800c\u72b6\u6001\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\u4ece\u672c\u8d28\u4e0a\u770b\uff0c\\(dp\\) \u8868\u662f\u72b6\u6001\u548c\u5b50\u95ee\u9898\u7684\u89e3\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\u4e2d\u8f83\u5c0f\u7684\u90a3\u4e00\u4e2a\u51b3\u5b9a\u3002

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u53ef\u63a8\u51fa\u56fe 14-12 \u6240\u793a\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff1a

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

    \u56fe 14-12 \u00a0 \u6700\u4f18\u5b50\u7ed3\u6784\u4e0e\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b

    Note

    \u6839\u636e\u5b9a\u4e49\u597d\u7684 \\(dp\\) \u8868\uff0c\u601d\u8003\u539f\u95ee\u9898\u548c\u5b50\u95ee\u9898\u7684\u5173\u7cfb\uff0c\u627e\u51fa\u901a\u8fc7\u5b50\u95ee\u9898\u7684\u6700\u4f18\u89e3\u6765\u6784\u9020\u539f\u95ee\u9898\u7684\u6700\u4f18\u89e3\u7684\u65b9\u6cd5\uff0c\u5373\u6700\u4f18\u5b50\u7ed3\u6784\u3002

    \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\u5904\u5728\u9996\u884c\u7684\u72b6\u6001\u53ea\u80fd\u4ece\u5176\u5de6\u8fb9\u7684\u72b6\u6001\u5f97\u6765\uff0c\u5904\u5728\u9996\u5217\u7684\u72b6\u6001\u53ea\u80fd\u4ece\u5176\u4e0a\u8fb9\u7684\u72b6\u6001\u5f97\u6765\uff0c\u56e0\u6b64\u9996\u884c \\(i = 0\\) \u548c\u9996\u5217 \\(j = 0\\) \u662f\u8fb9\u754c\u6761\u4ef6\u3002

    \u5982\u56fe 14-13 \u6240\u793a\uff0c\u7531\u4e8e\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\u5faa\u73af\u6765\u904d\u5386\u77e9\u9635\uff0c\u5916\u5faa\u73af\u904d\u5386\u5404\u884c\uff0c\u5185\u5faa\u73af\u904d\u5386\u5404\u5217\u3002

    \u56fe 14-13 \u00a0 \u8fb9\u754c\u6761\u4ef6\u4e0e\u72b6\u6001\u8f6c\u79fb\u987a\u5e8f

    Note

    \u8fb9\u754c\u6761\u4ef6\u5728\u52a8\u6001\u89c4\u5212\u4e2d\u7528\u4e8e\u521d\u59cb\u5316 \\(dp\\) \u8868\uff0c\u5728\u641c\u7d22\u4e2d\u7528\u4e8e\u526a\u679d\u3002

    \u72b6\u6001\u8f6c\u79fb\u987a\u5e8f\u7684\u6838\u5fc3\u662f\u8981\u4fdd\u8bc1\u5728\u8ba1\u7b97\u5f53\u524d\u95ee\u9898\u7684\u89e3\u65f6\uff0c\u6240\u6709\u5b83\u4f9d\u8d56\u7684\u66f4\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\u90fd\u5df2\u7ecf\u88ab\u6b63\u786e\u5730\u8ba1\u7b97\u51fa\u6765\u3002

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u6211\u4eec\u5df2\u7ecf\u53ef\u4ee5\u76f4\u63a5\u5199\u51fa\u52a8\u6001\u89c4\u5212\u4ee3\u7801\u3002\u7136\u800c\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/#1","title":"1. \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\u9012\u5f52\u51fd\u6570\u5305\u62ec\u4ee5\u4e0b\u8981\u7d20\u3002

    • \u9012\u5f52\u53c2\u6570\uff1a\u72b6\u6001 \\([i, j]\\) \u3002
    • \u8fd4\u56de\u503c\uff1a\u4ece \\([0, 0]\\) \u5230 \\([i, j]\\) \u7684\u6700\u5c0f\u8def\u5f84\u548c \\(dp[i, j]\\) \u3002
    • \u7ec8\u6b62\u6761\u4ef6\uff1a\u5f53 \\(i = 0\\) \u4e14 \\(j = 0\\) \u65f6\uff0c\u8fd4\u56de\u4ee3\u4ef7 \\(grid[0, 0]\\) \u3002
    • \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\u3002

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 or j < 0:\n        return inf\n    # \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    up = min_path_sum_dfs(grid, i - 1, j)\n    left = 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\n    return min(left, up) + grid[i][j]\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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return 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\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n}\n
    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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return 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\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return Math.min(left, up) + grid[i][j];\n}\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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return 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\n    int up = MinPathSumDFS(grid, i - 1, j);\n    int left = MinPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return Math.Min(left, up) + grid[i][j];\n}\n
    min_path_sum.go
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfunc minPathSumDFS(grid [][]int, i, j int) int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0 && j == 0 {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return math.MaxInt\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    up := minPathSumDFS(grid, i-1, j)\n    left := minPathSumDFS(grid, i, j-1)\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return int(math.Min(float64(left), float64(up))) + grid[i][j]\n}\n
    min_path_sum.swift
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfunc minPathSumDFS(grid: [[Int]], i: Int, j: Int) -> Int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return .max\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    let up = minPathSumDFS(grid: grid, i: i - 1, j: j)\n    let left = minPathSumDFS(grid: grid, i: i, j: j - 1)\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return min(left, up) + grid[i][j]\n}\n
    min_path_sum.js
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfunction minPathSumDFS(grid, i, j) {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i === 0 && j === 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Infinity;\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return Math.min(left, up) + grid[i][j];\n}\n
    min_path_sum.ts
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfunction minPathSumDFS(\n    grid: Array<Array<number>>,\n    i: number,\n    j: number\n): number {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i === 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Infinity;\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    const up = minPathSumDFS(grid, i - 1, j);\n    const left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return Math.min(left, up) + grid[i][j];\n}\n
    min_path_sum.dart
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(List<List<int>> grid, int i, int j) {\n  // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n  if (i == 0 && j == 0) {\n    return grid[0][0];\n  }\n  // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n  if (i < 0 || j < 0) {\n    // \u5728 Dart \u4e2d\uff0cint \u7c7b\u578b\u662f\u56fa\u5b9a\u8303\u56f4\u7684\u6574\u6570\uff0c\u4e0d\u5b58\u5728\u8868\u793a\u201c\u65e0\u7a77\u5927\u201d\u7684\u503c\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n  int up = minPathSumDFS(grid, i - 1, j);\n  int left = minPathSumDFS(grid, i, j - 1);\n  // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n  return min(left, up) + grid[i][j];\n}\n
    min_path_sum.rs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfn min_path_sum_dfs(grid: &Vec<Vec<i32>>, i: i32, j: i32) -> i32 {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0 && j == 0 {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return i32::MAX;\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    let up = min_path_sum_dfs(grid, i - 1, j);\n    let left = 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\n    std::cmp::min(left, up) + grid[i as usize][j as usize]\n}\n
    min_path_sum.c
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nint minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return 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\n    int up = minPathSumDFS(grid, i - 1, j);\n    int left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n}\n
    min_path_sum.kt
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22 */\nfun minPathSumDFS(\n    grid: Array<Array<Int>>,\n    i: Int,\n    j: Int\n): Int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 && j == 0) {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Int.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\n    val up = minPathSumDFS(grid, i - 1, j)\n    val left = minPathSumDFS(grid, i, j - 1)\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return (min(left.toDouble(), up.toDouble()) + grid[i][j]).toInt()\n}\n
    min_path_sum.rb
    [class]{}-[func]{min_path_sum_dfs}\n
    min_path_sum.zig
    // \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u66b4\u529b\u641c\u7d22\nfn minPathSumDFS(grid: anytype, i: i32, j: i32) i32 {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 and j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 or j < 0) {\n        return std.math.maxInt(i32);\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    var up = minPathSumDFS(grid, i - 1, j);\n    var left = minPathSumDFS(grid, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    return @min(left, up) + grid[@as(usize, @intCast(i))][@as(usize, @intCast(j))];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-14 \u7ed9\u51fa\u4e86\u4ee5 \\(dp[2, 1]\\) \u4e3a\u6839\u8282\u70b9\u7684\u9012\u5f52\u6811\uff0c\u5176\u4e2d\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

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u9020\u6210\u91cd\u53e0\u5b50\u95ee\u9898\u7684\u539f\u56e0\u4e3a\uff1a\u5b58\u5728\u591a\u6761\u8def\u5f84\u53ef\u4ee5\u4ece\u5de6\u4e0a\u89d2\u5230\u8fbe\u67d0\u4e00\u5355\u5143\u683c\u3002

    \u56fe 14-14 \u00a0 \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\uff0c\u56e0\u6b64\u5b9e\u9645\u7684\u8def\u5f84\u6570\u91cf\u4f1a\u5c11\u4e00\u4e9b\u3002

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

    \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\u5e76\u5c06\u91cd\u53e0\u5b50\u95ee\u9898\u8fdb\u884c\u526a\u679d\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig min_path_sum.py
    def min_path_sum_dfs_mem(\n    grid: 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\n    if i == 0 and j == 0:\n        return grid[0][0]\n    # \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 or j < 0:\n        return inf\n    # \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][j] != -1:\n        return mem[i][j]\n    # \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    up = min_path_sum_dfs_mem(grid, mem, i - 1, j)\n    left = 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\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return INT_MAX;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = 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\n    mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n
    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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Integer.MAX_VALUE;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = 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\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\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\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return int.MaxValue;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    int up = MinPathSumDFSMem(grid, mem, i - 1, j);\n    int left = 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\n    mem[i][j] = Math.Min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n
    min_path_sum.go
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc minPathSumDFSMem(grid, mem [][]int, i, j int) int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0 && j == 0 {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return math.MaxInt\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    up := minPathSumDFSMem(grid, mem, i-1, j)\n    left := 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\n    mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]\n    return mem[i][j]\n}\n
    min_path_sum.swift
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc minPathSumDFSMem(grid: [[Int]], mem: inout [[Int]], i: Int, j: Int) -> Int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0, j == 0 {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return .max\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][j] != -1 {\n        return mem[i][j]\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    let up = minPathSumDFSMem(grid: grid, mem: &mem, i: i - 1, j: j)\n    let left = minPathSumDFSMem(grid: grid, mem: &mem, i: i, j: j - 1)\n    // \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    mem[i][j] = min(left, up) + grid[i][j]\n    return mem[i][j]\n}\n
    min_path_sum.js
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction minPathSumDFSMem(grid, mem, i, j) {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i === 0 && j === 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Infinity;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] !== -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = 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\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n
    min_path_sum.ts
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction minPathSumDFSMem(\n    grid: Array<Array<number>>,\n    mem: Array<Array<number>>,\n    i: number,\n    j: number\n): number {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i === 0 && j === 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Infinity;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    const up = minPathSumDFSMem(grid, mem, i - 1, j);\n    const left = 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\n    mem[i][j] = Math.min(left, up) + grid[i][j];\n    return mem[i][j];\n}\n
    min_path_sum.dart
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(List<List<int>> grid, List<List<int>> mem, int i, int j) {\n  // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n  if (i == 0 && j == 0) {\n    return grid[0][0];\n  }\n  // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n  if (i < 0 || j < 0) {\n    // \u5728 Dart \u4e2d\uff0cint \u7c7b\u578b\u662f\u56fa\u5b9a\u8303\u56f4\u7684\u6574\u6570\uff0c\u4e0d\u5b58\u5728\u8868\u793a\u201c\u65e0\u7a77\u5927\u201d\u7684\u503c\n    return BigInt.from(2).pow(31).toInt();\n  }\n  // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n  if (mem[i][j] != -1) {\n    return mem[i][j];\n  }\n  // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n  int up = minPathSumDFSMem(grid, mem, i - 1, j);\n  int left = 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\n  mem[i][j] = min(left, up) + grid[i][j];\n  return mem[i][j];\n}\n
    min_path_sum.rs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfn min_path_sum_dfs_mem(grid: &Vec<Vec<i32>>, mem: &mut Vec<Vec<i32>>, i: i32, j: i32) -> i32 {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if i == 0 && j == 0 {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if i < 0 || j < 0 {\n        return i32::MAX;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i as usize][j as usize] != -1 {\n        return mem[i as usize][j as usize];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    let up = min_path_sum_dfs_mem(grid, mem, i - 1, j);\n    let left = 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\n    mem[i as usize][j as usize] = std::cmp::min(left, up) + grid[i as usize][j as usize];\n    mem[i as usize][j as usize]\n}\n
    min_path_sum.c
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 && j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return INT_MAX;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j];\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    int up = minPathSumDFSMem(grid, mem, i - 1, j);\n    int left = 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\n    mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;\n    return mem[i][j];\n}\n
    min_path_sum.kt
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfun minPathSumDFSMem(\n    grid: Array<Array<Int>>,\n    mem: Array<Array<Int>>,\n    i: Int,\n    j: Int\n): Int {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 && j == 0) {\n        return grid[0][0]\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 || j < 0) {\n        return Int.MAX_VALUE\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][j] != -1) {\n        return mem[i][j]\n    }\n    // \u5de6\u8fb9\u548c\u4e0a\u8fb9\u5355\u5143\u683c\u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    val up = minPathSumDFSMem(grid, mem, i - 1, j)\n    val left = 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\n    mem[i][j] = (min(left.toDouble(), up.toDouble()) + grid[i][j]).toInt()\n    return mem[i][j]\n}\n
    min_path_sum.rb
    [class]{}-[func]{min_path_sum_dfs_mem}\n
    min_path_sum.zig
    // \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\nfn minPathSumDFSMem(grid: anytype, mem: anytype, i: i32, j: i32) i32 {\n    // \u82e5\u4e3a\u5de6\u4e0a\u89d2\u5355\u5143\u683c\uff0c\u5219\u7ec8\u6b62\u641c\u7d22\n    if (i == 0 and j == 0) {\n        return grid[0][0];\n    }\n    // \u82e5\u884c\u5217\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de +\u221e \u4ee3\u4ef7\n    if (i < 0 or j < 0) {\n        return std.math.maxInt(i32);\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))] != -1) {\n        return mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))];\n    }\n    // \u8ba1\u7b97\u4ece\u5de6\u4e0a\u89d2\u5230 (i-1, j) \u548c (i, j-1) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    var up = minPathSumDFSMem(grid, mem, i - 1, j);\n    var left = minPathSumDFSMem(grid, mem, i, j - 1);\n    // \u8fd4\u56de\u4ece\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    // \u8bb0\u5f55\u5e76\u8fd4\u56de\u5de6\u4e0a\u89d2\u5230 (i, j) \u7684\u6700\u5c0f\u8def\u5f84\u4ee3\u4ef7\n    mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))] = @min(left, up) + grid[@as(usize, @intCast(i))][@as(usize, @intCast(j))];\n    return mem[@as(usize, @intCast(i))][@as(usize, @intCast(j))];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 14-15 \u6240\u793a\uff0c\u5728\u5f15\u5165\u8bb0\u5fc6\u5316\u540e\uff0c\u6240\u6709\u5b50\u95ee\u9898\u7684\u89e3\u53ea\u9700\u8ba1\u7b97\u4e00\u6b21\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u72b6\u6001\u603b\u6570\uff0c\u5373\u7f51\u683c\u5c3a\u5bf8 \\(O(nm)\\) \u3002

    \u56fe 14-15 \u00a0 \u8bb0\u5fc6\u5316\u641c\u7d22\u9012\u5f52\u6811

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

    \u57fa\u4e8e\u8fed\u4ee3\u5b9e\u73b0\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    n, m = len(grid), len(grid[0])\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * m for _ in range(n)]\n    dp[0][0] = grid[0][0]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in range(1, m):\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for i in range(1, n):\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in range(1, n):\n        for j in range(1, m):\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n    return dp[n - 1][m - 1]\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(vector<vector<int>> &grid) {\n    int n = grid.size(), m = grid[0].size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n, vector<int>(m));\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (int i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i < n; i++) {\n        for (int j = 1; j < m; j++) {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n][m];\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (int i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i < n; i++) {\n        for (int j = 1; j < m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint MinPathSumDP(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n, m];\n    dp[0, 0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[0, j] = dp[0, j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (int i = 1; i < n; i++) {\n        dp[i, 0] = dp[i - 1, 0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i < n; i++) {\n        for (int j = 1; j < m; j++) {\n            dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1, m - 1];\n}\n
    min_path_sum.go
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc minPathSumDP(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n)\n    for i := 0; i < n; i++ {\n        dp[i] = make([]int, m)\n    }\n    dp[0][0] = grid[0][0]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j := 1; j < m; j++ {\n        dp[0][j] = dp[0][j-1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for i := 1; i < n; i++ {\n        dp[i][0] = dp[i-1][0] + grid[i][0]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i < n; i++ {\n        for j := 1; j < m; j++ {\n            dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]\n        }\n    }\n    return dp[n-1][m-1]\n}\n
    min_path_sum.swift
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc minPathSumDP(grid: [[Int]]) -> Int {\n    let n = grid.count\n    let m = grid[0].count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: m), count: n)\n    dp[0][0] = grid[0][0]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in 1 ..< m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for i in 1 ..< n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1 ..< n {\n        for j in 1 ..< m {\n            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n
    min_path_sum.js
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction minPathSumDP(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n }, () =>\n        Array.from({ length: m }, () => 0)\n    );\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (let j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (let i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i < n; i++) {\n        for (let j = 1; j < m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    min_path_sum.ts
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction minPathSumDP(grid: Array<Array<number>>): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n }, () =>\n        Array.from({ length: m }, () => 0)\n    );\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (let j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (let i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i < n; i++) {\n        for (let j: number = 1; j < m; j++) {\n            dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    min_path_sum.dart
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(List<List<int>> grid) {\n  int n = grid.length, m = grid[0].length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n, (i) => List.filled(m, 0));\n  dp[0][0] = grid[0][0];\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n  for (int j = 1; j < m; j++) {\n    dp[0][j] = dp[0][j - 1] + grid[0][j];\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n  for (int i = 1; i < n; i++) {\n    dp[i][0] = dp[i - 1][0] + grid[i][0];\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n  for (int i = 1; i < n; i++) {\n    for (int j = 1; j < m; j++) {\n      dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n    }\n  }\n  return dp[n - 1][m - 1];\n}\n
    min_path_sum.rs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfn min_path_sum_dp(grid: &Vec<Vec<i32>>) -> i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; m]; n];\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in 1..m {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1..n {\n        for j in 1..m {\n            dp[i][j] = std::cmp::min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    dp[n - 1][m - 1]\n}\n
    min_path_sum.c
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nint minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc(n * sizeof(int *));\n    for (int i = 0; i < n; i++) {\n        dp[i] = calloc(m, sizeof(int));\n    }\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (int i = 1; i < n; i++) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i < n; i++) {\n        for (int j = 1; j < m; j++) {\n            dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    int res = dp[n - 1][m - 1];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i < n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n
    min_path_sum.kt
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212 */\nfun minPathSumDP(grid: Array<Array<Int>>): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n) { IntArray(m) }\n    dp[0][0] = grid[0][0]\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (j in 1..<m) {\n        dp[0][j] = dp[0][j - 1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (i in 1..<n) {\n        dp[i][0] = dp[i - 1][0] + grid[i][0]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (i in 1..<n) {\n        for (j in 1..<m) {\n            dp[i][j] =\n                (min(dp[i][j - 1].toDouble(), dp[i - 1][j].toDouble()) + grid[i][j]).toInt()\n        }\n    }\n    return dp[n - 1][m - 1]\n}\n
    min_path_sum.rb
    [class]{}-[func]{min_path_sum_dp}\n
    min_path_sum.zig
    // \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u52a8\u6001\u89c4\u5212\nfn minPathSumDP(comptime grid: anytype) i32 {\n    comptime var n = grid.len;\n    comptime var m = grid[0].len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][m]i32{[_]i32{0} ** m} ** n;\n    dp[0][0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (1..m) |j| {\n        dp[0][j] = dp[0][j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    for (1..n) |i| {\n        dp[i][0] = dp[i - 1][0] + grid[i][0];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (1..n) |i| {\n        for (1..m) |j| {\n            dp[i][j] = @min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];\n        }\n    }\n    return dp[n - 1][m - 1];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-16 \u5c55\u793a\u4e86\u6700\u5c0f\u8def\u5f84\u548c\u7684\u72b6\u6001\u8f6c\u79fb\u8fc7\u7a0b\uff0c\u5176\u904d\u5386\u4e86\u6574\u4e2a\u7f51\u683c\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nm)\\) \u3002

    \u6570\u7ec4 dp \u5927\u5c0f\u4e3a \\(n \\times m\\) \uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nm)\\) \u3002

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

    \u56fe 14-16 \u00a0 \u6700\u5c0f\u8def\u5f84\u548c\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    "},{"location":"chapter_dynamic_programming/dp_solution_pipeline/#4","title":"4. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7531\u4e8e\u6bcf\u4e2a\u683c\u5b50\u53ea\u4e0e\u5176\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

    \u8bf7\u6ce8\u610f\uff0c\u56e0\u4e3a\u6570\u7ec4 dp \u53ea\u80fd\u8868\u793a\u4e00\u884c\u7684\u72b6\u6001\uff0c\u6240\u4ee5\u6211\u4eec\u65e0\u6cd5\u63d0\u524d\u521d\u59cb\u5316\u9996\u5217\u72b6\u6001\uff0c\u800c\u662f\u5728\u904d\u5386\u6bcf\u884c\u65f6\u66f4\u65b0\u5b83\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig min_path_sum.py
    def min_path_sum_dp_comp(grid: list[list[int]]) -> int:\n    \"\"\"\u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n, m = len(grid), len(grid[0])\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [0] * m\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0]\n    for j in range(1, m):\n        dp[j] = dp[j - 1] + grid[0][j]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in range(1, n):\n        # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0]\n        # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in range(1, m):\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n    return dp[m - 1]\n
    min_path_sum.cpp
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(vector<vector<int>> &grid) {\n    int n = grid.size(), m = grid[0].size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(m);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (int j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j < m; j++) {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.java
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(int[][] grid) {\n    int n = grid.length, m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[m];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (int j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j < m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.cs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint MinPathSumDPComp(int[][] grid) {\n    int n = grid.Length, m = grid[0].Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[m];\n    dp[0] = grid[0][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j < m; j++) {\n            dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.go
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc minPathSumDPComp(grid [][]int) int {\n    n, m := len(grid), len(grid[0])\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, m)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0]\n    for j := 1; j < m; j++ {\n        dp[j] = dp[j-1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i < n; i++ {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0]\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j := 1; j < m; j++ {\n            dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]\n        }\n    }\n    return dp[m-1]\n}\n
    min_path_sum.swift
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc minPathSumDPComp(grid: [[Int]]) -> Int {\n    let n = grid.count\n    let m = grid[0].count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: 0, count: m)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0]\n    for j in 1 ..< m {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in 1 ..< n {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0]\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in 1 ..< m {\n            dp[j] = min(dp[j - 1], dp[j]) + grid[i][j]\n        }\n    }\n    return dp[m - 1]\n}\n
    min_path_sum.js
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction minPathSumDPComp(grid) {\n    const n = grid.length,\n        m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = new Array(m);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (let j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (let i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (let j = 1; j < m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.ts
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction minPathSumDPComp(grid: Array<Array<number>>): number {\n    const n = grid.length,\n        m = grid[0].length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = new Array(m);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (let j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (let i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (let j = 1; j < m; j++) {\n            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    min_path_sum.dart
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(List<List<int>> grid) {\n  int n = grid.length, m = grid[0].length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(m, 0);\n  dp[0] = grid[0][0];\n  for (int j = 1; j < m; j++) {\n    dp[j] = dp[j - 1] + grid[0][j];\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n  for (int i = 1; i < n; i++) {\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    dp[0] = dp[0] + grid[i][0];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n    for (int j = 1; j < m; j++) {\n      dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];\n    }\n  }\n  return dp[m - 1];\n}\n
    min_path_sum.rs
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn min_path_sum_dp_comp(grid: &Vec<Vec<i32>>) -> i32 {\n    let (n, m) = (grid.len(), grid[0].len());\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; m];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for j in 1..m {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in 1..n {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in 1..m {\n            dp[j] = std::cmp::min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    dp[m - 1]\n}\n
    min_path_sum.c
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(m, sizeof(int));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (int j = 1; j < m; j++) {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i < n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j < m; j++) {\n            dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    int res = dp[m - 1];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    min_path_sum.kt
    /* \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun minPathSumDPComp(grid: Array<Array<Int>>): Int {\n    val n = grid.size\n    val m = grid[0].size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(m)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0]\n    for (j in 1..<m) {\n        dp[j] = dp[j - 1] + grid[0][j]\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (i in 1..<n) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0]\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (j in 1..<m) {\n            dp[j] = (min(dp[j - 1].toDouble(), dp[j].toDouble()) + grid[i][j]).toInt()\n        }\n    }\n    return dp[m - 1]\n}\n
    min_path_sum.rb
    [class]{}-[func]{min_path_sum_dp_comp}\n
    min_path_sum.zig
    // \u6700\u5c0f\u8def\u5f84\u548c\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn minPathSumDPComp(comptime grid: anytype) i32 {\n    comptime var n = grid.len;\n    comptime var m = grid[0].len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** m;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    dp[0] = grid[0][0];\n    for (1..m) |j| {\n        dp[j] = dp[j - 1] + grid[0][j];\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (1..n) |i| {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        dp[0] = dp[0] + grid[i][0];\n        for (1..m) |j| {\n            dp[j] = @min(dp[j - 1], dp[j]) + grid[i][j];\n        }\n    }\n    return dp[m - 1];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/edit_distance_problem/","title":"14.6 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898","text":"

    \u7f16\u8f91\u8ddd\u79bb\uff0c\u4e5f\u79f0 Levenshtein \u8ddd\u79bb\uff0c\u6307\u4e24\u4e2a\u5b57\u7b26\u4e32\u4e4b\u95f4\u4e92\u76f8\u8f6c\u6362\u7684\u6700\u5c11\u4fee\u6539\u6b21\u6570\uff0c\u901a\u5e38\u7528\u4e8e\u5728\u4fe1\u606f\u68c0\u7d22\u548c\u81ea\u7136\u8bed\u8a00\u5904\u7406\u4e2d\u5ea6\u91cf\u4e24\u4e2a\u5e8f\u5217\u7684\u76f8\u4f3c\u5ea6\u3002

    Question

    \u8f93\u5165\u4e24\u4e2a\u5b57\u7b26\u4e32 \\(s\\) \u548c \\(t\\) \uff0c\u8fd4\u56de\u5c06 \\(s\\) \u8f6c\u6362\u4e3a \\(t\\) \u6240\u9700\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u3002

    \u4f60\u53ef\u4ee5\u5728\u4e00\u4e2a\u5b57\u7b26\u4e32\u4e2d\u8fdb\u884c\u4e09\u79cd\u7f16\u8f91\u64cd\u4f5c\uff1a\u63d2\u5165\u4e00\u4e2a\u5b57\u7b26\u3001\u5220\u9664\u4e00\u4e2a\u5b57\u7b26\u3001\u5c06\u5b57\u7b26\u66ff\u6362\u4e3a\u4efb\u610f\u4e00\u4e2a\u5b57\u7b26\u3002

    \u5982\u56fe 14-27 \u6240\u793a\uff0c\u5c06 kitten \u8f6c\u6362\u4e3a sitting \u9700\u8981\u7f16\u8f91 3 \u6b65\uff0c\u5305\u62ec 2 \u6b21\u66ff\u6362\u64cd\u4f5c\u4e0e 1 \u6b21\u6dfb\u52a0\u64cd\u4f5c\uff1b\u5c06 hello \u8f6c\u6362\u4e3a algo \u9700\u8981 3 \u6b65\uff0c\u5305\u62ec 2 \u6b21\u66ff\u6362\u64cd\u4f5c\u548c 1 \u6b21\u5220\u9664\u64cd\u4f5c\u3002

    \u56fe 14-27 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u7684\u793a\u4f8b\u6570\u636e

    \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898\u53ef\u4ee5\u5f88\u81ea\u7136\u5730\u7528\u51b3\u7b56\u6811\u6a21\u578b\u6765\u89e3\u91ca\u3002\u5b57\u7b26\u4e32\u5bf9\u5e94\u6811\u8282\u70b9\uff0c\u4e00\u8f6e\u51b3\u7b56\uff08\u4e00\u6b21\u7f16\u8f91\u64cd\u4f5c\uff09\u5bf9\u5e94\u6811\u7684\u4e00\u6761\u8fb9\u3002

    \u5982\u56fe 14-28 \u6240\u793a\uff0c\u5728\u4e0d\u9650\u5236\u64cd\u4f5c\u7684\u60c5\u51b5\u4e0b\uff0c\u6bcf\u4e2a\u8282\u70b9\u90fd\u53ef\u4ee5\u6d3e\u751f\u51fa\u8bb8\u591a\u6761\u8fb9\uff0c\u6bcf\u6761\u8fb9\u5bf9\u5e94\u4e00\u79cd\u64cd\u4f5c\uff0c\u8fd9\u610f\u5473\u7740\u4ece hello \u8f6c\u6362\u5230 algo \u6709\u8bb8\u591a\u79cd\u53ef\u80fd\u7684\u8def\u5f84\u3002

    \u4ece\u51b3\u7b56\u6811\u7684\u89d2\u5ea6\u770b\uff0c\u672c\u9898\u7684\u76ee\u6807\u662f\u6c42\u89e3\u8282\u70b9 hello \u548c\u8282\u70b9 algo \u4e4b\u95f4\u7684\u6700\u77ed\u8def\u5f84\u3002

    \u56fe 14-28 \u00a0 \u57fa\u4e8e\u51b3\u7b56\u6811\u6a21\u578b\u8868\u793a\u7f16\u8f91\u8ddd\u79bb\u95ee\u9898

    "},{"location":"chapter_dynamic_programming/edit_distance_problem/#1","title":"1. \u00a0 \u52a8\u6001\u89c4\u5212\u601d\u8def","text":"

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

    \u6bcf\u4e00\u8f6e\u7684\u51b3\u7b56\u662f\u5bf9\u5b57\u7b26\u4e32 \\(s\\) \u8fdb\u884c\u4e00\u6b21\u7f16\u8f91\u64cd\u4f5c\u3002

    \u6211\u4eec\u5e0c\u671b\u5728\u7f16\u8f91\u64cd\u4f5c\u7684\u8fc7\u7a0b\u4e2d\uff0c\u95ee\u9898\u7684\u89c4\u6a21\u9010\u6e10\u7f29\u5c0f\uff0c\u8fd9\u6837\u624d\u80fd\u6784\u5efa\u5b50\u95ee\u9898\u3002\u8bbe\u5b57\u7b26\u4e32 \\(s\\) \u548c \\(t\\) \u7684\u957f\u5ea6\u5206\u522b\u4e3a \\(n\\) \u548c \\(m\\) \uff0c\u6211\u4eec\u5148\u8003\u8651\u4e24\u5b57\u7b26\u4e32\u5c3e\u90e8\u7684\u5b57\u7b26 \\(s[n-1]\\) \u548c \\(t[m-1]\\) \u3002

    • \u82e5 \\(s[n-1]\\) \u548c \\(t[m-1]\\) \u76f8\u540c\uff0c\u6211\u4eec\u53ef\u4ee5\u8df3\u8fc7\u5b83\u4eec\uff0c\u76f4\u63a5\u8003\u8651 \\(s[n-2]\\) \u548c \\(t[m-2]\\) \u3002
    • \u82e5 \\(s[n-1]\\) \u548c \\(t[m-1]\\) \u4e0d\u540c\uff0c\u6211\u4eec\u9700\u8981\u5bf9 \\(s\\) \u8fdb\u884c\u4e00\u6b21\u7f16\u8f91\uff08\u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\uff09\uff0c\u4f7f\u5f97\u4e24\u5b57\u7b26\u4e32\u5c3e\u90e8\u7684\u5b57\u7b26\u76f8\u540c\uff0c\u4ece\u800c\u53ef\u4ee5\u8df3\u8fc7\u5b83\u4eec\uff0c\u8003\u8651\u89c4\u6a21\u66f4\u5c0f\u7684\u95ee\u9898\u3002

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u6211\u4eec\u5728\u5b57\u7b26\u4e32 \\(s\\) \u4e2d\u8fdb\u884c\u7684\u6bcf\u4e00\u8f6e\u51b3\u7b56\uff08\u7f16\u8f91\u64cd\u4f5c\uff09\uff0c\u90fd\u4f1a\u4f7f\u5f97 \\(s\\) \u548c \\(t\\) \u4e2d\u5269\u4f59\u7684\u5f85\u5339\u914d\u5b57\u7b26\u53d1\u751f\u53d8\u5316\u3002\u56e0\u6b64\uff0c\u72b6\u6001\u4e3a\u5f53\u524d\u5728 \\(s\\) \u548c \\(t\\) \u4e2d\u8003\u8651\u7684\u7b2c \\(i\\) \u548c\u7b2c \\(j\\) \u4e2a\u5b57\u7b26\uff0c\u8bb0\u4e3a \\([i, j]\\) \u3002

    \u72b6\u6001 \\([i, j]\\) \u5bf9\u5e94\u7684\u5b50\u95ee\u9898\uff1a\u5c06 \\(s\\) \u7684\u524d \\(i\\) \u4e2a\u5b57\u7b26\u66f4\u6539\u4e3a \\(t\\) \u7684\u524d \\(j\\) \u4e2a\u5b57\u7b26\u6240\u9700\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u3002

    \u81f3\u6b64\uff0c\u5f97\u5230\u4e00\u4e2a\u5c3a\u5bf8\u4e3a \\((i+1) \\times (j+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

    \u8003\u8651\u5b50\u95ee\u9898 \\(dp[i, j]\\) \uff0c\u5176\u5bf9\u5e94\u7684\u4e24\u4e2a\u5b57\u7b26\u4e32\u7684\u5c3e\u90e8\u5b57\u7b26\u4e3a \\(s[i-1]\\) \u548c \\(t[j-1]\\) \uff0c\u53ef\u6839\u636e\u4e0d\u540c\u7f16\u8f91\u64cd\u4f5c\u5206\u4e3a\u56fe 14-29 \u6240\u793a\u7684\u4e09\u79cd\u60c5\u51b5\u3002

    1. \u5728 \\(s[i-1]\\) \u4e4b\u540e\u6dfb\u52a0 \\(t[j-1]\\) \uff0c\u5219\u5269\u4f59\u5b50\u95ee\u9898 \\(dp[i, j-1]\\) \u3002
    2. \u5220\u9664 \\(s[i-1]\\) \uff0c\u5219\u5269\u4f59\u5b50\u95ee\u9898 \\(dp[i-1, j]\\) \u3002
    3. \u5c06 \\(s[i-1]\\) \u66ff\u6362\u4e3a \\(t[j-1]\\) \uff0c\u5219\u5269\u4f59\u5b50\u95ee\u9898 \\(dp[i-1, j-1]\\) \u3002

    \u56fe 14-29 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u7684\u72b6\u6001\u8f6c\u79fb

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u53ef\u5f97\u6700\u4f18\u5b50\u7ed3\u6784\uff1a\\(dp[i, j]\\) \u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u7b49\u4e8e \\(dp[i, j-1]\\)\u3001\\(dp[i-1, j]\\)\u3001\\(dp[i-1, j-1]\\) \u4e09\u8005\u4e2d\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\uff0c\u518d\u52a0\u4e0a\u672c\u6b21\u7684\u7f16\u8f91\u6b65\u6570 \\(1\\) \u3002\u5bf9\u5e94\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e3a\uff1a

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

    \u8bf7\u6ce8\u610f\uff0c\u5f53 \\(s[i-1]\\) \u548c \\(t[j-1]\\) \u76f8\u540c\u65f6\uff0c\u65e0\u987b\u7f16\u8f91\u5f53\u524d\u5b57\u7b26\uff0c\u8fd9\u79cd\u60c5\u51b5\u4e0b\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e3a\uff1a

    \\[ dp[i, j] = dp[i-1, j-1] \\]

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

    \u5f53\u4e24\u5b57\u7b26\u4e32\u90fd\u4e3a\u7a7a\u65f6\uff0c\u7f16\u8f91\u6b65\u6570\u4e3a \\(0\\) \uff0c\u5373 \\(dp[0, 0] = 0\\) \u3002\u5f53 \\(s\\) \u4e3a\u7a7a\u4f46 \\(t\\) \u4e0d\u4e3a\u7a7a\u65f6\uff0c\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u7b49\u4e8e \\(t\\) \u7684\u957f\u5ea6\uff0c\u5373\u9996\u884c \\(dp[0, j] = j\\) \u3002\u5f53 \\(s\\) \u4e0d\u4e3a\u7a7a\u4f46 \\(t\\) \u4e3a\u7a7a\u65f6\uff0c\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u7b49\u4e8e \\(s\\) \u7684\u957f\u5ea6\uff0c\u5373\u9996\u5217 \\(dp[i, 0] = i\\) \u3002

    \u89c2\u5bdf\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\uff0c\u89e3 \\(dp[i, j]\\) \u4f9d\u8d56\u5de6\u65b9\u3001\u4e0a\u65b9\u3001\u5de6\u4e0a\u65b9\u7684\u89e3\uff0c\u56e0\u6b64\u901a\u8fc7\u4e24\u5c42\u5faa\u73af\u6b63\u5e8f\u904d\u5386\u6574\u4e2a \\(dp\\) \u8868\u5373\u53ef\u3002

    "},{"location":"chapter_dynamic_programming/edit_distance_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig edit_distance.py
    def edit_distance_dp(s: str, t: str) -> int:\n    \"\"\"\u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\n    n, m = len(s), len(t)\n    dp = [[0] * (m + 1) for _ in range(n + 1)]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for i in range(1, n + 1):\n        dp[i][0] = i\n    for j in range(1, m + 1):\n        dp[0][j] = j\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in range(1, n + 1):\n        for j in range(1, m + 1):\n            if s[i - 1] == t[j - 1]:\n                # \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1]\n            else:\n                # \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1\n    return dp[n][m]\n
    edit_distance.cpp
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint editDistanceDP(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    edit_distance.java
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint editDistanceDP(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[][] dp = new int[n + 1][m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = Math.min(Math.min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    edit_distance.cs
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint EditDistanceDP(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[,] dp = new int[n + 1, m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int i = 1; i <= n; i++) {\n        dp[i, 0] = i;\n    }\n    for (int j = 1; j <= m; j++) {\n        dp[0, j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i, j] = dp[i - 1, j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n, m];\n}\n
    edit_distance.go
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc editDistanceDP(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, m+1)\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for i := 1; i <= n; i++ {\n        dp[i][0] = i\n    }\n    for j := 1; j <= m; j++ {\n        dp[0][j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i <= n; i++ {\n        for j := 1; j <= m; j++ {\n            if s[i-1] == t[j-1] {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i-1][j-1]\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n
    edit_distance.swift
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc editDistanceDP(s: String, t: String) -> Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for i in 1 ... n {\n        dp[i][0] = i\n    }\n    for j in 1 ... m {\n        dp[0][j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1 ... n {\n        for j in 1 ... m {\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1\n            }\n        }\n    }\n    return dp[n][m]\n}\n
    edit_distance.js
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction editDistanceDP(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (let i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    edit_distance.ts
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction editDistanceDP(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: m + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (let i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (let j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i <= n; i++) {\n        for (let j = 1; j <= m; j++) {\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] =\n                    Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    edit_distance.dart
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint editDistanceDP(String s, String t) {\n  int n = s.length, m = t.length;\n  List<List<int>> dp = List.generate(n + 1, (_) => List.filled(m + 1, 0));\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n  for (int i = 1; i <= n; i++) {\n    dp[i][0] = i;\n  }\n  for (int j = 1; j <= m; j++) {\n    dp[0][j] = j;\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n  for (int i = 1; i <= n; i++) {\n    for (int j = 1; j <= m; j++) {\n      if (s[i - 1] == t[j - 1]) {\n        // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n        dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n      }\n    }\n  }\n  return dp[n][m];\n}\n
    edit_distance.rs
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfn edit_distance_dp(s: &str, t: &str) -> i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![vec![0; m + 1]; n + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for i in 1..=n {\n        dp[i][0] = i as i32;\n    }\n    for j in 1..m {\n        dp[0][j] = j as i32;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1..=n {\n        for j in 1..=m {\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] =\n                    std::cmp::min(std::cmp::min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    dp[n][m]\n}\n
    edit_distance.c
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nint editDistanceDP(char *s, char *t, int n, int m) {\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(m + 1, sizeof(int));\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int i = 1; i <= n; i++) {\n        dp[i][0] = i;\n    }\n    for (int j = 1; j <= m; j++) {\n        dp[0][j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int j = 1; j <= m; j++) {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    int res = dp[n][m];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n
    edit_distance.kt
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212 */\nfun editDistanceDP(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = Array(n + 1) { IntArray(m + 1) }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (i in 1..n) {\n        dp[i][0] = i\n    }\n    for (j in 1..m) {\n        dp[0][j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (i in 1..n) {\n        for (j in 1..m) {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1]\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] =\n                    (min(\n                        min(dp[i][j - 1].toDouble(), dp[i - 1][j].toDouble()),\n                        dp[i - 1][j - 1].toDouble()\n                    ) + 1).toInt()\n            }\n        }\n    }\n    return dp[n][m]\n}\n
    edit_distance.rb
    [class]{}-[func]{edit_distance_dp}\n
    edit_distance.zig
    // \u7f16\u8f91\u8ddd\u79bb\uff1a\u52a8\u6001\u89c4\u5212\nfn editDistanceDP(comptime s: []const u8, comptime t: []const u8) i32 {\n    comptime var n = s.len;\n    comptime var m = t.len;\n    var dp = [_][m + 1]i32{[_]i32{0} ** (m + 1)} ** (n + 1);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (1..n + 1) |i| {\n        dp[i][0] = @intCast(i);\n    }\n    for (1..m + 1) |j| {\n        dp[0][j] = @intCast(j);\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (1..n + 1) |i| {\n        for (1..m + 1) |j| {\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[i][j] = dp[i - 1][j - 1];\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[i][j] = @min(@min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;\n            }\n        }\n    }\n    return dp[n][m];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 14-30 \u6240\u793a\uff0c\u7f16\u8f91\u8ddd\u79bb\u95ee\u9898\u7684\u72b6\u6001\u8f6c\u79fb\u8fc7\u7a0b\u4e0e\u80cc\u5305\u95ee\u9898\u975e\u5e38\u7c7b\u4f3c\uff0c\u90fd\u53ef\u4ee5\u770b\u4f5c\u586b\u5199\u4e00\u4e2a\u4e8c\u7ef4\u7f51\u683c\u7684\u8fc7\u7a0b\u3002

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

    \u56fe 14-30 \u00a0 \u7f16\u8f91\u8ddd\u79bb\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    "},{"location":"chapter_dynamic_programming/edit_distance_problem/#3","title":"3. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7531\u4e8e \\(dp[i,j]\\) \u662f\u7531\u4e0a\u65b9 \\(dp[i-1, j]\\)\u3001\u5de6\u65b9 \\(dp[i, j-1]\\)\u3001\u5de6\u4e0a\u65b9 \\(dp[i-1, j-1]\\) \u8f6c\u79fb\u800c\u6765\u7684\uff0c\u800c\u6b63\u5e8f\u904d\u5386\u4f1a\u4e22\u5931\u5de6\u4e0a\u65b9 \\(dp[i-1, j-1]\\) \uff0c\u5012\u5e8f\u904d\u5386\u65e0\u6cd5\u63d0\u524d\u6784\u5efa \\(dp[i, j-1]\\) \uff0c\u56e0\u6b64\u4e24\u79cd\u904d\u5386\u987a\u5e8f\u90fd\u4e0d\u53ef\u53d6\u3002

    \u4e3a\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u4e00\u4e2a\u53d8\u91cf leftup \u6765\u6682\u5b58\u5de6\u4e0a\u65b9\u7684\u89e3 \\(dp[i-1, j-1]\\) \uff0c\u4ece\u800c\u53ea\u9700\u8003\u8651\u5de6\u65b9\u548c\u4e0a\u65b9\u7684\u89e3\u3002\u6b64\u65f6\u7684\u60c5\u51b5\u4e0e\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u76f8\u540c\uff0c\u53ef\u4f7f\u7528\u6b63\u5e8f\u904d\u5386\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig edit_distance.py
    def edit_distance_dp_comp(s: str, t: str) -> int:\n    \"\"\"\u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n, m = len(s), len(t)\n    dp = [0] * (m + 1)\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in range(1, m + 1):\n        dp[j] = j\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in range(1, n + 1):\n        # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        leftup = dp[0]  # \u6682\u5b58 dp[i-1, j-1]\n        dp[0] += 1\n        # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in range(1, m + 1):\n            temp = dp[j]\n            if s[i - 1] == t[j - 1]:\n                # \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup\n            else:\n                # \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = min(dp[j - 1], dp[j], leftup) + 1\n            leftup = temp  # \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n    return dp[m]\n
    edit_distance.cpp
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint editDistanceDPComp(string s, string t) {\n    int n = s.length(), m = t.length();\n    vector<int> dp(m + 1, 0);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j <= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.java
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint editDistanceDPComp(String s, String t) {\n    int n = s.length(), m = t.length();\n    int[] dp = new int[m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j <= m; j++) {\n            int temp = dp[j];\n            if (s.charAt(i - 1) == t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = Math.min(Math.min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.cs
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint EditDistanceDPComp(string s, string t) {\n    int n = s.Length, m = t.Length;\n    int[] dp = new int[m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j <= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.go
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc editDistanceDPComp(s string, t string) int {\n    n := len(s)\n    m := len(t)\n    dp := make([]int, m+1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j := 1; j <= m; j++ {\n        dp[j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i := 1; i <= n; i++ {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        leftUp := dp[0] // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j := 1; j <= m; j++ {\n            temp := dp[j]\n            if s[i-1] == t[j-1] {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftUp\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1\n            }\n            leftUp = temp // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n
    edit_distance.swift
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc editDistanceDPComp(s: String, t: String) -> Int {\n    let n = s.utf8CString.count\n    let m = t.utf8CString.count\n    var dp = Array(repeating: 0, count: m + 1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in 1 ... m {\n        dp[j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in 1 ... n {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        var leftup = dp[0] // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in 1 ... m {\n            let temp = dp[j]\n            if s.utf8CString[i - 1] == t.utf8CString[j - 1] {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1\n            }\n            leftup = temp // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n
    edit_distance.js
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction editDistanceDPComp(s, t) {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (let j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (let i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        let leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (let j = 1; j <= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.ts
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction editDistanceDPComp(s: string, t: string): number {\n    const n = s.length,\n        m = t.length;\n    const dp = new Array(m + 1).fill(0);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (let j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (let i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        let leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (let j = 1; j <= m; j++) {\n            const temp = dp[j];\n            if (s.charAt(i - 1) === t.charAt(j - 1)) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    edit_distance.dart
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint editDistanceDPComp(String s, String t) {\n  int n = s.length, m = t.length;\n  List<int> dp = List.filled(m + 1, 0);\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n  for (int j = 1; j <= m; j++) {\n    dp[j] = j;\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n  for (int i = 1; i <= n; i++) {\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n    int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n    dp[0] = i;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n    for (int j = 1; j <= m; j++) {\n      int temp = dp[j];\n      if (s[i - 1] == t[j - 1]) {\n        // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n        dp[j] = leftup;\n      } else {\n        // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;\n      }\n      leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n    }\n  }\n  return dp[m];\n}\n
    edit_distance.rs
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn edit_distance_dp_comp(s: &str, t: &str) -> i32 {\n    let (n, m) = (s.len(), t.len());\n    let mut dp = vec![0; m + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for j in 1..m {\n        dp[j] = j as i32;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for i in 1..=n {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        let mut leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i as i32;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for j in 1..=m {\n            let temp = dp[j];\n            if s.chars().nth(i - 1) == t.chars().nth(j - 1) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = std::cmp::min(std::cmp::min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    dp[m]\n}\n
    edit_distance.c
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint editDistanceDPComp(char *s, char *t, int n, int m) {\n    int *dp = calloc(m + 1, sizeof(int));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (int j = 1; j <= m; j++) {\n        dp[j] = j;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (int i = 1; i <= n; i++) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        int leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i;\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (int j = 1; j <= m; j++) {\n            int temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    int res = dp[m];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    edit_distance.kt
    /* \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun editDistanceDPComp(s: String, t: String): Int {\n    val n = s.length\n    val m = t.length\n    val dp = IntArray(m + 1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (j in 1..m) {\n        dp[j] = j\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (i in 1..n) {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        var leftup = dp[0] // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = i\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (j in 1..m) {\n            val temp = dp[j]\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = (min(min(dp[j - 1].toDouble(), dp[j].toDouble()), leftup.toDouble()) + 1).toInt()\n            }\n            leftup = temp // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m]\n}\n
    edit_distance.rb
    [class]{}-[func]{edit_distance_dp_comp}\n
    edit_distance.zig
    // \u7f16\u8f91\u8ddd\u79bb\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn editDistanceDPComp(comptime s: []const u8, comptime t: []const u8) i32 {\n    comptime var n = s.len;\n    comptime var m = t.len;\n    var dp = [_]i32{0} ** (m + 1);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\n    for (1..m + 1) |j| {\n        dp[j] = @intCast(j);\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\n    for (1..n + 1) |i| {\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u5217\n        var leftup = dp[0]; // \u6682\u5b58 dp[i-1, j-1]\n        dp[0] = @intCast(i);\n        // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u5217\n        for (1..m + 1) |j| {\n            var temp = dp[j];\n            if (s[i - 1] == t[j - 1]) {\n                // \u82e5\u4e24\u5b57\u7b26\u76f8\u7b49\uff0c\u5219\u76f4\u63a5\u8df3\u8fc7\u6b64\u4e24\u5b57\u7b26\n                dp[j] = leftup;\n            } else {\n                // \u6700\u5c11\u7f16\u8f91\u6b65\u6570 = \u63d2\u5165\u3001\u5220\u9664\u3001\u66ff\u6362\u8fd9\u4e09\u79cd\u64cd\u4f5c\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570 + 1\n                dp[j] = @min(@min(dp[j - 1], dp[j]), leftup) + 1;\n            }\n            leftup = temp; // \u66f4\u65b0\u4e3a\u4e0b\u4e00\u8f6e\u7684 dp[i-1, j-1]\n        }\n    }\n    return dp[m];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/","title":"14.1 \u00a0 \u521d\u63a2\u52a8\u6001\u89c4\u5212","text":"

    \u300c\u52a8\u6001\u89c4\u5212 dynamic programming\u300d\u662f\u4e00\u4e2a\u91cd\u8981\u7684\u7b97\u6cd5\u8303\u5f0f\uff0c\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\uff1f

    \u5982\u56fe 14-1 \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

    \u56fe 14-1 \u00a0 \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if state == n:\n        res[0] += 1\n    # \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices:\n        # \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if state + choice > n:\n            continue\n        # \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res)\n        # \u56de\u9000\n\ndef climbing_stairs_backtrack(n: int) -> int:\n    \"\"\"\u722c\u697c\u68af\uff1a\u56de\u6eaf\"\"\"\n    choices = [1, 2]  # \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    state = 0  # \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    res = [0]  # \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res)\n    return res[0]\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\n    if (state == n)\n        res[0]++;\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (auto &choice : choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n)\n            continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\n    vector<int> choices = {1, 2}; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    int state = 0;                // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    vector<int> res = {0};        // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res);\n    return res[0];\n}\n
    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\n    if (state == n)\n        res.set(0, res.get(0) + 1);\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (Integer choice : choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n)\n            continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\n    List<Integer> choices = Arrays.asList(1, 2); // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    int state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    List<Integer> res = new ArrayList<>();\n    res.add(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\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\n    if (state == n)\n        res[0]++;\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    foreach (int choice in choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n)\n            continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        Backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint ClimbingStairsBacktrack(int n) {\n    List<int> choices = [1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    int state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    List<int> res = [0]; // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    Backtrack(choices, state, n, res);\n    return res[0];\n}\n
    climbing_stairs_backtrack.go
    /* \u56de\u6eaf */\nfunc backtrack(choices []int, state, n int, res []int) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if state == n {\n        res[0] = res[0] + 1\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for _, choice := range choices {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if state+choice > n {\n            continue\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state+choice, n, res)\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfunc climbingStairsBacktrack(n int) int {\n    // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    choices := []int{1, 2}\n    // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    state := 0\n    res := make([]int, 1)\n    // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    res[0] = 0\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n
    climbing_stairs_backtrack.swift
    /* \u56de\u6eaf */\nfunc backtrack(choices: [Int], state: Int, n: Int, res: inout [Int]) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if state == n {\n        res[0] += 1\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for choice in choices {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if state + choice > n {\n            continue\n        }\n        backtrack(choices: choices, state: state + choice, n: n, res: &res)\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfunc climbingStairsBacktrack(n: Int) -> Int {\n    let choices = [1, 2] // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    let state = 0 // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    var res: [Int] = []\n    res.append(0) // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices: choices, state: state, n: n, res: &res)\n    return res[0]\n}\n
    climbing_stairs_backtrack.js
    /* \u56de\u6eaf */\nfunction backtrack(choices, state, n, res) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (const choice of choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n) continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfunction climbingStairsBacktrack(n) {\n    const choices = [1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    const state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    const res = new Map();\n    res.set(0, 0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n
    climbing_stairs_backtrack.ts
    /* \u56de\u6eaf */\nfunction backtrack(\n    choices: number[],\n    state: number,\n    n: number,\n    res: Map<0, any>\n): void {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state === n) res.set(0, res.get(0) + 1);\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (const choice of choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n) continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfunction climbingStairsBacktrack(n: number): number {\n    const choices = [1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    const state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    const res = new Map();\n    res.set(0, 0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res);\n    return res.get(0);\n}\n
    climbing_stairs_backtrack.dart
    /* \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\n  if (state == n) {\n    res[0]++;\n  }\n  // \u904d\u5386\u6240\u6709\u9009\u62e9\n  for (int choice in choices) {\n    // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n    if (state + choice > n) continue;\n    // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n    backtrack(choices, state + choice, n, res);\n    // \u56de\u9000\n  }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\n  List<int> choices = [1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n  int state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n  List<int> res = [];\n  res.add(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n  backtrack(choices, state, n, res);\n  return res[0];\n}\n
    climbing_stairs_backtrack.rs
    /* \u56de\u6eaf */\nfn backtrack(choices: &[i32], state: i32, n: i32, res: &mut [i32]) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if state == n {\n        res[0] = res[0] + 1;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for &choice in choices {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if state + choice > n {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfn climbing_stairs_backtrack(n: usize) -> i32 {\n    let choices = vec![1, 2]; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    let state = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    let mut res = Vec::new();\n    res.push(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(&choices, state, n as i32, &mut res);\n    res[0]\n}\n
    climbing_stairs_backtrack.c
    /* \u56de\u6eaf */\nvoid backtrack(int *choices, int state, int n, int *res, int len) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state == n)\n        res[0]++;\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (int i = 0; i < len; i++) {\n        int choice = choices[i];\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n)\n            continue;\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res, len);\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nint climbingStairsBacktrack(int n) {\n    int choices[2] = {1, 2}; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    int state = 0;           // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    int *res = (int *)malloc(sizeof(int));\n    *res = 0; // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    int len = sizeof(choices) / sizeof(int);\n    backtrack(choices, state, n, res, len);\n    int result = *res;\n    free(res);\n    return result;\n}\n
    climbing_stairs_backtrack.kt
    /* \u56de\u6eaf */\nfun backtrack(\n    choices: List<Int>,\n    state: Int,\n    n: Int,\n    res: MutableList<Int>\n) {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state == n) res[0] = res[0] + 1\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (choice in choices) {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n) continue\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res)\n        // \u56de\u9000\n    }\n}\n\n/* \u722c\u697c\u68af\uff1a\u56de\u6eaf */\nfun climbingStairsBacktrack(n: Int): Int {\n    val choices = mutableListOf(1, 2) // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    val state = 0 // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    val res = ArrayList<Int>()\n    res.add(0) // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(choices, state, n, res)\n    return res[0]\n}\n
    climbing_stairs_backtrack.rb
    [class]{}-[func]{backtrack}\n\n[class]{}-[func]{climbing_stairs_backtrack}\n
    climbing_stairs_backtrack.zig
    // \u56de\u6eaf\nfn backtrack(choices: []i32, state: i32, n: i32, res: std.ArrayList(i32)) void {\n    // \u5f53\u722c\u5230\u7b2c n \u9636\u65f6\uff0c\u65b9\u6848\u6570\u91cf\u52a0 1\n    if (state == n) {\n        res.items[0] = res.items[0] + 1;\n    }\n    // \u904d\u5386\u6240\u6709\u9009\u62e9\n    for (choices) |choice| {\n        // \u526a\u679d\uff1a\u4e0d\u5141\u8bb8\u8d8a\u8fc7\u7b2c n \u9636\n        if (state + choice > n) {\n            continue;\n        }\n        // \u5c1d\u8bd5\uff1a\u505a\u51fa\u9009\u62e9\uff0c\u66f4\u65b0\u72b6\u6001\n        backtrack(choices, state + choice, n, res);\n        // \u56de\u9000\n    }\n}\n\n// \u722c\u697c\u68af\uff1a\u56de\u6eaf\nfn climbingStairsBacktrack(n: usize) !i32 {\n    var choices = [_]i32{ 1, 2 }; // \u53ef\u9009\u62e9\u5411\u4e0a\u722c 1 \u9636\u6216 2 \u9636\n    var state: i32 = 0; // \u4ece\u7b2c 0 \u9636\u5f00\u59cb\u722c\n    var res = std.ArrayList(i32).init(std.heap.page_allocator);\n    defer res.deinit();\n    try res.append(0); // \u4f7f\u7528 res[0] \u8bb0\u5f55\u65b9\u6848\u6570\u91cf\n    backtrack(&choices, state, @intCast(n), res);\n    return res.items[0];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1411","title":"14.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\u6c42\u89e3\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

    \u6211\u4eec\u53ef\u4ee5\u5c1d\u8bd5\u4ece\u95ee\u9898\u5206\u89e3\u7684\u89d2\u5ea6\u5206\u6790\u8fd9\u9053\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\uff1a

    \\[ dp[i-1], dp[i-2], \\dots, 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\u3002\u6362\u53e5\u8bdd\u8bf4\uff0c\u6211\u4eec\u53ea\u80fd\u4ece\u7b2c \\(i -1\\) \u9636\u6216\u7b2c \\(i - 2\\) \u9636\u8fc8\u5411\u7b2c \\(i\\) \u9636\u3002

    \u7531\u6b64\u4fbf\u53ef\u5f97\u51fa\u4e00\u4e2a\u91cd\u8981\u63a8\u8bba\uff1a\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\u3002\u516c\u5f0f\u5982\u4e0b\uff1a

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

    \u8fd9\u610f\u5473\u7740\u5728\u722c\u697c\u68af\u95ee\u9898\u4e2d\uff0c\u5404\u4e2a\u5b50\u95ee\u9898\u4e4b\u95f4\u5b58\u5728\u9012\u63a8\u5173\u7cfb\uff0c\u539f\u95ee\u9898\u7684\u89e3\u53ef\u4ee5\u7531\u5b50\u95ee\u9898\u7684\u89e3\u6784\u5efa\u5f97\u6765\u3002\u56fe 14-2 \u5c55\u793a\u4e86\u8be5\u9012\u63a8\u5173\u7cfb\u3002

    \u56fe 14-2 \u00a0 \u65b9\u6848\u6570\u91cf\u9012\u63a8\u5173\u7cfb

    \u6211\u4eec\u53ef\u4ee5\u6839\u636e\u9012\u63a8\u516c\u5f0f\u5f97\u5230\u66b4\u529b\u641c\u7d22\u89e3\u6cd5\u3002\u4ee5 \\(dp[n]\\) \u4e3a\u8d77\u59cb\u70b9\uff0c\u9012\u5f52\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\u662f\u5df2\u77e5\u7684\uff0c\u5373 \\(dp[1] = 1\\)\u3001\\(dp[2] = 2\\) \uff0c\u8868\u793a\u722c\u5230\u7b2c \\(1\\)\u3001\\(2\\) \u9636\u5206\u522b\u6709 \\(1\\)\u3001\\(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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig climbing_stairs_dfs.py
    def dfs(i: int) -> int:\n    \"\"\"\u641c\u7d22\"\"\"\n    # \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 or i == 2:\n        return i\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1) + dfs(i - 2)\n    return count\n\ndef climbing_stairs_dfs(n: int) -> int:\n    \"\"\"\u722c\u697c\u68af\uff1a\u641c\u7d22\"\"\"\n    return dfs(n)\n
    climbing_stairs_dfs.cpp
    /* \u641c\u7d22 */\nint dfs(int i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.java
    /* \u641c\u7d22 */\nint dfs(int i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.cs
    /* \u641c\u7d22 */\nint DFS(int i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1) + DFS(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint ClimbingStairsDFS(int n) {\n    return DFS(n);\n}\n
    climbing_stairs_dfs.go
    /* \u641c\u7d22 */\nfunc dfs(i int) int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfs(i-1) + dfs(i-2)\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfunc climbingStairsDFS(n int) int {\n    return dfs(n)\n}\n
    climbing_stairs_dfs.swift
    /* \u641c\u7d22 */\nfunc dfs(i: Int) -> Int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1) + dfs(i: i - 2)\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfunc climbingStairsDFS(n: Int) -> Int {\n    dfs(i: n)\n}\n
    climbing_stairs_dfs.js
    /* \u641c\u7d22 */\nfunction dfs(i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfunction climbingStairsDFS(n) {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.ts
    /* \u641c\u7d22 */\nfunction dfs(i: number): number {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i === 1 || i === 2) return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfunction climbingStairsDFS(n: number): number {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.dart
    /* \u641c\u7d22 */\nint dfs(int i) {\n  // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n  if (i == 1 || i == 2) return i;\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1) + dfs(i - 2);\n  return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\n  return dfs(n);\n}\n
    climbing_stairs_dfs.rs
    /* \u641c\u7d22 */\nfn dfs(i: usize) -> i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1) + dfs(i - 2);\n    count\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfn climbing_stairs_dfs(n: usize) -> i32 {\n    dfs(n)\n}\n
    climbing_stairs_dfs.c
    /* \u641c\u7d22 */\nint dfs(int i) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nint climbingStairsDFS(int n) {\n    return dfs(n);\n}\n
    climbing_stairs_dfs.kt
    /* \u641c\u7d22 */\nfun dfs(i: Int): Int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2) return i\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1) + dfs(i - 2)\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u641c\u7d22 */\nfun climbingStairsDFS(n: Int): Int {\n    return dfs(n)\n}\n
    climbing_stairs_dfs.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{climbing_stairs_dfs}\n
    climbing_stairs_dfs.zig
    // \u641c\u7d22\nfn dfs(i: usize) i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 or i == 2) {\n        return @intCast(i);\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    var count = dfs(i - 1) + dfs(i - 2);\n    return count;\n}\n\n// \u722c\u697c\u68af\uff1a\u641c\u7d22\nfn climbingStairsDFS(comptime n: usize) i32 {\n    return dfs(n);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-3 \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\u5c5e\u4e8e\u7206\u70b8\u5f0f\u589e\u957f\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

    \u56fe 14-3 \u00a0 \u722c\u697c\u68af\u5bf9\u5e94\u9012\u5f52\u6811

    \u89c2\u5bdf\u56fe 14-3 \uff0c\u6307\u6570\u9636\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u662f\u201c\u91cd\u53e0\u5b50\u95ee\u9898\u201d\u5bfc\u81f4\u7684\u3002\u4f8b\u5982 \\(dp[9]\\) \u88ab\u5206\u89e3\u4e3a \\(dp[8]\\) \u548c \\(dp[7]\\) \uff0c\\(dp[8]\\) \u88ab\u5206\u89e3\u4e3a \\(dp[7]\\) \u548c \\(dp[6]\\) \uff0c\u4e24\u8005\u90fd\u5305\u542b\u5b50\u95ee\u9898 \\(dp[7]\\) \u3002

    \u4ee5\u6b64\u7c7b\u63a8\uff0c\u5b50\u95ee\u9898\u4e2d\u5305\u542b\u66f4\u5c0f\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u5b50\u5b50\u5b59\u5b59\u65e0\u7a77\u5c3d\u4e5f\u3002\u7edd\u5927\u90e8\u5206\u8ba1\u7b97\u8d44\u6e90\u90fd\u6d6a\u8d39\u5728\u8fd9\u4e9b\u91cd\u53e0\u7684\u5b50\u95ee\u9898\u4e0a\u3002

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1412","title":"14.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\u4e3a\u6b64\uff0c\u6211\u4eec\u58f0\u660e\u4e00\u4e2a\u6570\u7ec4 mem \u6765\u8bb0\u5f55\u6bcf\u4e2a\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5e76\u5728\u641c\u7d22\u8fc7\u7a0b\u4e2d\u5c06\u91cd\u53e0\u5b50\u95ee\u9898\u526a\u679d\u3002

    1. \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\u3002
    2. \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\u907f\u514d\u91cd\u590d\u8ba1\u7b97\u8be5\u5b50\u95ee\u9898\u3002

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if i == 1 or i == 2:\n        return i\n    # \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if mem[i] != -1:\n        return mem[i]\n    # dp[i] = dp[i-1] + dp[i-2]\n    count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    # \u8bb0\u5f55 dp[i]\n    mem[i] = count\n    return count\n\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\n    mem = [-1] * (n + 1)\n    return dfs(n, mem)\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\n    if (i == 1 || i == 2)\n        return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\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\n    vector<int> mem(n + 1, -1);\n    return dfs(n, mem);\n}\n
    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\n    if (i == 1 || i == 2)\n        return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\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\n    int[] mem = new int[n + 1];\n    Arrays.fill(mem, -1);\n    return dfs(n, mem);\n}\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\n    if (i == 1 || i == 2)\n        return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = DFS(i - 1, mem) + DFS(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\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\n    int[] mem = new int[n + 1];\n    Array.Fill(mem, -1);\n    return DFS(n, mem);\n}\n
    climbing_stairs_dfs_mem.go
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc dfsMem(i int, mem []int) int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i\n    }\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    count := dfsMem(i-1, mem) + dfsMem(i-2, mem)\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc climbingStairsDFSMem(n int) int {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    mem := make([]int, n+1)\n    for i := range mem {\n        mem[i] = -1\n    }\n    return dfsMem(n, mem)\n}\n
    climbing_stairs_dfs_mem.swift
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc dfs(i: Int, mem: inout [Int]) -> Int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i\n    }\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if mem[i] != -1 {\n        return mem[i]\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i: i - 1, mem: &mem) + dfs(i: i - 2, mem: &mem)\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc climbingStairsDFSMem(n: Int) -> Int {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    var mem = Array(repeating: -1, count: n + 1)\n    return dfs(i: n, mem: &mem)\n}\n
    climbing_stairs_dfs_mem.js
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction dfs(i, mem) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i === 1 || i === 2) return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction climbingStairsDFSMem(n) {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.ts
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction dfs(i: number, mem: number[]): number {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i === 1 || i === 2) return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1) return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    const count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction climbingStairsDFSMem(n: number): number {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    const mem = new Array(n + 1).fill(-1);\n    return dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.dart
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, List<int> mem) {\n  // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n  if (i == 1 || i == 2) return i;\n  // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n  if (mem[i] != -1) return mem[i];\n  // dp[i] = dp[i-1] + dp[i-2]\n  int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n  // \u8bb0\u5f55 dp[i]\n  mem[i] = count;\n  return count;\n}\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\n  List<int> mem = List.filled(n + 1, -1);\n  return dfs(n, mem);\n}\n
    climbing_stairs_dfs_mem.rs
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfn dfs(i: usize, mem: &mut [i32]) -> i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if i == 1 || i == 2 {\n        return i as i32;\n    }\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if mem[i] != -1 {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    let count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    count\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfn climbing_stairs_dfs_mem(n: usize) -> i32 {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    let mut mem = vec![-1; n + 1];\n    dfs(n, &mut mem)\n}\n
    climbing_stairs_dfs_mem.c
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nint dfs(int i, int *mem) {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2)\n        return i;\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1)\n        return mem[i];\n    // dp[i] = dp[i-1] + dp[i-2]\n    int count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\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\n    int *mem = (int *)malloc((n + 1) * sizeof(int));\n    for (int i = 0; i <= n; i++) {\n        mem[i] = -1;\n    }\n    int result = dfs(n, mem);\n    free(mem);\n    return result;\n}\n
    climbing_stairs_dfs_mem.kt
    /* \u8bb0\u5fc6\u5316\u641c\u7d22 */\nfun dfs(i: Int, mem: IntArray): Int {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 || i == 2) return i\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1) return mem[i]\n    // dp[i] = dp[i-1] + dp[i-2]\n    val count = dfs(i - 1, mem) + dfs(i - 2, mem)\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count\n    return count\n}\n\n/* \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfun climbingStairsDFSMem(n: Int): Int {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    val mem = IntArray(n + 1)\n    Arrays.fill(mem, -1)\n    return dfs(n, mem)\n}\n
    climbing_stairs_dfs_mem.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{climbing_stairs_dfs_mem}\n
    climbing_stairs_dfs_mem.zig
    // \u8bb0\u5fc6\u5316\u641c\u7d22\nfn dfs(i: usize, mem: []i32) i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (i == 1 or i == 2) {\n        return @intCast(i);\n    }\n    // \u82e5\u5b58\u5728\u8bb0\u5f55 dp[i] \uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u4e4b\n    if (mem[i] != -1) {\n        return mem[i];\n    }\n    // dp[i] = dp[i-1] + dp[i-2]\n    var count = dfs(i - 1, mem) + dfs(i - 2, mem);\n    // \u8bb0\u5f55 dp[i]\n    mem[i] = count;\n    return count;\n}\n\n// \u722c\u697c\u68af\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\nfn climbingStairsDFSMem(comptime n: usize) i32 {\n    // mem[i] \u8bb0\u5f55\u722c\u5230\u7b2c i \u9636\u7684\u65b9\u6848\u603b\u6570\uff0c-1 \u4ee3\u8868\u65e0\u8bb0\u5f55\n    var mem = [_]i32{ -1 } ** (n + 1);\n    return dfs(n, &mem);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u89c2\u5bdf\u56fe 14-4 \uff0c\u7ecf\u8fc7\u8bb0\u5fc6\u5316\u5904\u7406\u540e\uff0c\u6240\u6709\u91cd\u53e0\u5b50\u95ee\u9898\u90fd\u53ea\u9700\u8ba1\u7b97\u4e00\u6b21\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(n)\\) \uff0c\u8fd9\u662f\u4e00\u4e2a\u5de8\u5927\u7684\u98de\u8dc3\u3002

    \u56fe 14-4 \u00a0 \u8bb0\u5fc6\u5316\u641c\u7d22\u5bf9\u5e94\u9012\u5f52\u6811

    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1413","title":"14.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\u3002\u4e4b\u540e\uff0c\u901a\u8fc7\u56de\u6eaf\u9010\u5c42\u6536\u96c6\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u6784\u5efa\u51fa\u539f\u95ee\u9898\u7684\u89e3\u3002

    \u4e0e\u4e4b\u76f8\u53cd\uff0c\u52a8\u6001\u89c4\u5212\u662f\u4e00\u79cd\u201c\u4ece\u5e95\u81f3\u9876\u201d\u7684\u65b9\u6cd5\uff1a\u4ece\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\u5f00\u59cb\uff0c\u8fed\u4ee3\u5730\u6784\u5efa\u66f4\u5927\u5b50\u95ee\u9898\u7684\u89e3\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\u53ea\u9700\u4f7f\u7528\u5faa\u73af\u8fed\u4ee3\u5b9e\u73b0\uff0c\u65e0\u987b\u4f7f\u7528\u9012\u5f52\u3002\u5728\u4ee5\u4e0b\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u521d\u59cb\u5316\u4e00\u4e2a\u6570\u7ec4 dp \u6765\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5b83\u8d77\u5230\u4e86\u4e0e\u8bb0\u5fc6\u5316\u641c\u7d22\u4e2d\u6570\u7ec4 mem \u76f8\u540c\u7684\u8bb0\u5f55\u4f5c\u7528\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig climbing_stairs_dp.py
    def climbing_stairs_dp(n: int) -> int:\n    \"\"\"\u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\n    if n == 1 or n == 2:\n        return n\n    # \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp = [0] * (n + 1)\n    # \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[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\n    for i in range(3, n + 1):\n        dp[i] = dp[i - 1] + dp[i - 2]\n    return dp[n]\n
    climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    vector<int> dp(n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.java
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[] dp = new int[n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint ClimbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int[] dp = new int[n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.go
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsDP(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    dp := make([]int, n+1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1\n    dp[2] = 2\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i := 3; i <= n; i++ {\n        dp[i] = dp[i-1] + dp[i-2]\n    }\n    return dp[n]\n}\n
    climbing_stairs_dp.swift
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsDP(n: Int) -> Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = Array(repeating: 0, count: n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1\n    dp[2] = 2\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3 ... n {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n
    climbing_stairs_dp.js
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsDP(n) {\n    if (n === 1 || n === 2) return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = new Array(n + 1).fill(-1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.ts
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsDP(n: number): number {\n    if (n === 1 || n === 2) return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    const dp = new Array(n + 1).fill(-1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (let i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    climbing_stairs_dp.dart
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\n  if (n == 1 || n == 2) return n;\n  // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n  List<int> dp = List.filled(n + 1, 0);\n  // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n  dp[1] = 1;\n  dp[2] = 2;\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n  for (int i = 3; i <= n; i++) {\n    dp[i] = dp[i - 1] + dp[i - 2];\n  }\n  return dp[n];\n}\n
    climbing_stairs_dp.rs
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfn climbing_stairs_dp(n: usize) -> i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    let mut dp = vec![-1; n + 1];\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i in 3..=n {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    dp[n]\n}\n
    climbing_stairs_dp.c
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDP(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    int *dp = (int *)malloc((n + 1) * sizeof(int));\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (int i = 3; i <= n; i++) {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    int result = dp[n];\n    free(dp);\n    return result;\n}\n
    climbing_stairs_dp.kt
    /* \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212 */\nfun climbingStairsDP(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    val dp = IntArray(n + 1)\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1\n    dp[2] = 2\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (i in 3..n) {\n        dp[i] = dp[i - 1] + dp[i - 2]\n    }\n    return dp[n]\n}\n
    climbing_stairs_dp.rb
    [class]{}-[func]{climbing_stairs_dp}\n
    climbing_stairs_dp.zig
    // \u722c\u697c\u68af\uff1a\u52a8\u6001\u89c4\u5212\nfn climbingStairsDP(comptime n: usize) i32 {\n    // \u5df2\u77e5 dp[1] \u548c dp[2] \uff0c\u8fd4\u56de\u4e4b\n    if (n == 1 or n == 2) {\n        return @intCast(n);\n    }\n    // \u521d\u59cb\u5316 dp \u8868\uff0c\u7528\u4e8e\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\n    var dp = [_]i32{-1} ** (n + 1);\n    // \u521d\u59cb\u72b6\u6001\uff1a\u9884\u8bbe\u6700\u5c0f\u5b50\u95ee\u9898\u7684\u89e3\n    dp[1] = 1;\n    dp[2] = 2;\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for (3..n + 1) |i| {\n        dp[i] = dp[i - 1] + dp[i - 2];\n    }\n    return dp[n];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-5 \u6a21\u62df\u4e86\u4ee5\u4e0a\u4ee3\u7801\u7684\u6267\u884c\u8fc7\u7a0b\u3002

    \u56fe 14-5 \u00a0 \u722c\u697c\u68af\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \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\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\uff0c\u722c\u697c\u68af\u95ee\u9898\u7684\u72b6\u6001\u5b9a\u4e49\u4e3a\u5f53\u524d\u6240\u5728\u697c\u68af\u9636\u6570 \\(i\\) \u3002

    \u6839\u636e\u4ee5\u4e0a\u5185\u5bb9\uff0c\u6211\u4eec\u53ef\u4ee5\u603b\u7ed3\u51fa\u52a8\u6001\u89c4\u5212\u7684\u5e38\u7528\u672f\u8bed\u3002

    • \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\u3002
    • \u5c06\u6700\u5c0f\u5b50\u95ee\u9898\u5bf9\u5e94\u7684\u72b6\u6001\uff08\u7b2c \\(1\\) \u9636\u548c\u7b2c \\(2\\) \u9636\u697c\u68af\uff09\u79f0\u4e3a\u300c\u521d\u59cb\u72b6\u6001\u300d\u3002
    • \u5c06\u9012\u63a8\u516c\u5f0f \\(dp[i] = dp[i-1] + dp[i-2]\\) \u79f0\u4e3a\u300c\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u300d\u3002
    "},{"location":"chapter_dynamic_programming/intro_to_dynamic_programming/#1414","title":"14.1.4 \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7ec6\u5fc3\u7684\u8bfb\u8005\u53ef\u80fd\u53d1\u73b0\u4e86\uff0c\u7531\u4e8e \\(dp[i]\\) \u53ea\u4e0e \\(dp[i-1]\\) \u548c \\(dp[i-2]\\) \u6709\u5173\uff0c\u56e0\u6b64\u6211\u4eec\u65e0\u987b\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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig climbing_stairs_dp.py
    def climbing_stairs_dp_comp(n: int) -> int:\n    \"\"\"\u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    if n == 1 or n == 2:\n        return n\n    a, b = 1, 2\n    for _ in range(3, n + 1):\n        a, b = b, a + b\n    return b\n
    climbing_stairs_dp.cpp
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.java
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.cs
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint ClimbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.go
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsDPComp(n int) int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    a, b := 1, 2\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u4ece\u8f83\u5c0f\u5b50\u95ee\u9898\u9010\u6b65\u6c42\u89e3\u8f83\u5927\u5b50\u95ee\u9898\n    for i := 3; i <= n; i++ {\n        a, b = b, a+b\n    }\n    return b\n}\n
    climbing_stairs_dp.swift
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc climbingStairsDPComp(n: Int) -> Int {\n    if n == 1 || n == 2 {\n        return n\n    }\n    var a = 1\n    var b = 2\n    for _ in 3 ... n {\n        (a, b) = (b, a + b)\n    }\n    return b\n}\n
    climbing_stairs_dp.js
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsDPComp(n) {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i <= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.ts
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction climbingStairsDPComp(n: number): number {\n    if (n === 1 || n === 2) return n;\n    let a = 1,\n        b = 2;\n    for (let i = 3; i <= n; i++) {\n        const tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.dart
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\n  if (n == 1 || n == 2) return n;\n  int a = 1, b = 2;\n  for (int i = 3; i <= n; i++) {\n    int tmp = b;\n    b = a + b;\n    a = tmp;\n  }\n  return b;\n}\n
    climbing_stairs_dp.rs
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn climbing_stairs_dp_comp(n: usize) -> i32 {\n    if n == 1 || n == 2 {\n        return n as i32;\n    }\n    let (mut a, mut b) = (1, 2);\n    for _ in 3..=n {\n        let tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    b\n}\n
    climbing_stairs_dp.c
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint climbingStairsDPComp(int n) {\n    if (n == 1 || n == 2)\n        return n;\n    int a = 1, b = 2;\n    for (int i = 3; i <= n; i++) {\n        int tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    climbing_stairs_dp.kt
    /* \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun climbingStairsDPComp(n: Int): Int {\n    if (n == 1 || n == 2) return n\n    var a = 1\n    var b = 2\n    for (i in 3..n) {\n        val tmp = b\n        b += a\n        a = tmp\n    }\n    return b\n}\n
    climbing_stairs_dp.rb
    [class]{}-[func]{climbing_stairs_dp_comp}\n
    climbing_stairs_dp.zig
    // \u722c\u697c\u68af\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn climbingStairsDPComp(comptime n: usize) i32 {\n    if (n == 1 or n == 2) {\n        return @intCast(n);\n    }\n    var a: i32 = 1;\n    var b: i32 = 2;\n    for (3..n + 1) |_| {\n        var tmp = b;\n        b = a + b;\n        a = tmp;\n    }\n    return b;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u89c2\u5bdf\u4ee5\u4e0a\u4ee3\u7801\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\u81f3 \\(O(1)\\) \u3002

    \u5728\u52a8\u6001\u89c4\u5212\u95ee\u9898\u4e2d\uff0c\u5f53\u524d\u72b6\u6001\u5f80\u5f80\u4ec5\u4e0e\u524d\u9762\u6709\u9650\u4e2a\u72b6\u6001\u6709\u5173\uff0c\u8fd9\u65f6\u6211\u4eec\u53ef\u4ee5\u53ea\u4fdd\u7559\u5fc5\u8981\u7684\u72b6\u6001\uff0c\u901a\u8fc7\u201c\u964d\u7ef4\u201d\u6765\u8282\u7701\u5185\u5b58\u7a7a\u95f4\u3002\u8fd9\u79cd\u7a7a\u95f4\u4f18\u5316\u6280\u5de7\u88ab\u79f0\u4e3a\u201c\u6eda\u52a8\u53d8\u91cf\u201d\u6216\u201c\u6eda\u52a8\u6570\u7ec4\u201d\u3002

    "},{"location":"chapter_dynamic_programming/knapsack_problem/","title":"14.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\u6c42\u89e3\u6700\u5e38\u89c1\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\u548c\u4e00\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\u3002\u6bcf\u4e2a\u7269\u54c1\u53ea\u80fd\u9009\u62e9\u4e00\u6b21\uff0c\u95ee\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u80fd\u653e\u5165\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002

    \u89c2\u5bdf\u56fe 14-17 \uff0c\u7531\u4e8e\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

    \u56fe 14-17 \u00a0 0-1 \u80cc\u5305\u7684\u793a\u4f8b\u6570\u636e

    \u6211\u4eec\u53ef\u4ee5\u5c06 0-1 \u80cc\u5305\u95ee\u9898\u770b\u4f5c\u4e00\u4e2a\u7531 \\(n\\) \u8f6e\u51b3\u7b56\u7ec4\u6210\u7684\u8fc7\u7a0b\uff0c\u5bf9\u4e8e\u6bcf\u4e2a\u7269\u4f53\u90fd\u6709\u4e0d\u653e\u5165\u548c\u653e\u5165\u4e24\u79cd\u51b3\u7b56\uff0c\u56e0\u6b64\u8be5\u95ee\u9898\u6ee1\u8db3\u51b3\u7b56\u6811\u6a21\u578b\u3002

    \u8be5\u95ee\u9898\u7684\u76ee\u6807\u662f\u6c42\u89e3\u201c\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u80fd\u653e\u5165\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u201d\uff0c\u56e0\u6b64\u8f83\u5927\u6982\u7387\u662f\u4e00\u4e2a\u52a8\u6001\u89c4\u5212\u95ee\u9898\u3002

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

    \u5bf9\u4e8e\u6bcf\u4e2a\u7269\u54c1\u6765\u8bf4\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

    \u5f85\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\uff0c\u53ef\u5206\u4e3a\u4ee5\u4e0b\u4e24\u79cd\u60c5\u51b5\u3002

    • \u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u80cc\u5305\u5bb9\u91cf\u4e0d\u53d8\uff0c\u72b6\u6001\u53d8\u5316\u4e3a \\([i-1, c]\\) \u3002
    • \u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u80cc\u5305\u5bb9\u91cf\u51cf\u5c11 \\(wgt[i-1]\\) \uff0c\u4ef7\u503c\u589e\u52a0 \\(val[i-1]\\) \uff0c\u72b6\u6001\u53d8\u5316\u4e3a \\([i-1, c-wgt[i-1]]\\) \u3002

    \u4e0a\u8ff0\u5206\u6790\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\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\u3002\u7531\u6b64\u53ef\u63a8\u5bfc\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\u9996\u5217 \\(dp[i, 0]\\) \u548c\u9996\u884c \\(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

    \u6839\u636e\u4ee5\u4e0a\u5206\u6790\uff0c\u6211\u4eec\u63a5\u4e0b\u6765\u6309\u987a\u5e8f\u5b9e\u73b0\u66b4\u529b\u641c\u7d22\u3001\u8bb0\u5fc6\u5316\u641c\u7d22\u3001\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u3002

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

    \u641c\u7d22\u4ee3\u7801\u5305\u542b\u4ee5\u4e0b\u8981\u7d20\u3002

    • \u9012\u5f52\u53c2\u6570\uff1a\u72b6\u6001 \\([i, c]\\) \u3002
    • \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\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 or c == 0:\n        return 0\n    # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c:\n        return knapsack_dfs(wgt, val, i - 1, c)\n    # \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    no = knapsack_dfs(wgt, val, i - 1, c)\n    yes = 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\n    return max(no, yes)\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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int 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\n    return max(no, yes);\n}\n
    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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int 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\n    return Math.max(no, yes);\n}\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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (weight[i - 1] > c) {\n        return KnapsackDFS(weight, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = KnapsackDFS(weight, val, i - 1, c);\n    int 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\n    return Math.Max(no, yes);\n}\n
    knapsack.go
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfunc knapsackDFS(wgt, val []int, i, c int) int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i-1] > c {\n        return knapsackDFS(wgt, val, i-1, c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    no := knapsackDFS(wgt, val, i-1, c)\n    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\n    return int(math.Max(float64(no), float64(yes)))\n}\n
    knapsack.swift
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfunc knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -> Int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c {\n        return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c)\n    let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1]\n    // \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    return max(no, yes)\n}\n
    knapsack.js
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfunction knapsackDFS(wgt, val, i, c) {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const 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\n    return Math.max(no, yes);\n}\n
    knapsack.ts
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfunction knapsackDFS(\n    wgt: Array<number>,\n    val: Array<number>,\n    i: number,\n    c: number\n): number {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    const no = knapsackDFS(wgt, val, i - 1, c);\n    const 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\n    return Math.max(no, yes);\n}\n
    knapsack.dart
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nint knapsackDFS(List<int> wgt, List<int> val, int i, int c) {\n  // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n  if (wgt[i - 1] > c) {\n    return knapsackDFS(wgt, val, i - 1, c);\n  }\n  // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n  int no = knapsackDFS(wgt, val, i - 1, c);\n  int 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\n  return max(no, yes);\n}\n
    knapsack.rs
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfn knapsack_dfs(wgt: &[i32], val: &[i32], i: usize, c: usize) -> i32 {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c as i32 {\n        return knapsack_dfs(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    let no = knapsack_dfs(wgt, val, i - 1, c);\n    let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    std::cmp::max(no, yes)\n}\n
    knapsack.c
    /* 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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = knapsackDFS(wgt, val, i - 1, c);\n    int 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\n    return myMax(no, yes);\n}\n
    knapsack.kt
    /* 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22 */\nfun knapsackDFS(\n    wgt: IntArray,\n    value: IntArray,\n    i: Int,\n    c: Int\n): Int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, value, i - 1, c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    val no = knapsackDFS(wgt, value, i - 1, c)\n    val yes = knapsackDFS(wgt, value, i - 1, c - wgt[i - 1]) + value[i - 1]\n    // \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    return max(no.toDouble(), yes.toDouble()).toInt()\n}\n
    knapsack.rb
    [class]{}-[func]{knapsack_dfs}\n
    knapsack.zig
    // 0-1 \u80cc\u5305\uff1a\u66b4\u529b\u641c\u7d22\nfn knapsackDFS(wgt: []i32, val: []i32, i: usize, c: usize) i32 {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 or c == 0) {\n        return 0;\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFS(wgt, val, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    var no = knapsackDFS(wgt, val, i - 1, c);\n    var yes = knapsackDFS(wgt, val, i - 1, c - @as(usize, @intCast(wgt[i - 1]))) + val[i - 1];\n    // \u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    return @max(no, yes);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 14-18 \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\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(2^n)\\) \u3002

    \u89c2\u5bdf\u9012\u5f52\u6811\uff0c\u5bb9\u6613\u53d1\u73b0\u5176\u4e2d\u5b58\u5728\u91cd\u53e0\u5b50\u95ee\u9898\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\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

    \u56fe 14-18 \u00a0 0-1 \u80cc\u5305\u95ee\u9898\u7684\u66b4\u529b\u641c\u7d22\u9012\u5f52\u6811

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

    \u4e3a\u4e86\u4fdd\u8bc1\u91cd\u53e0\u5b50\u95ee\u9898\u53ea\u88ab\u8ba1\u7b97\u4e00\u6b21\uff0c\u6211\u4eec\u501f\u52a9\u8bb0\u5fc6\u5217\u8868 mem \u6765\u8bb0\u5f55\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u5176\u4e2d mem[i][c] \u5bf9\u5e94 \\(dp[i, c]\\) \u3002

    \u5f15\u5165\u8bb0\u5fc6\u5316\u4e4b\u540e\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u5b50\u95ee\u9898\u6570\u91cf\uff0c\u4e5f\u5c31\u662f \\(O(n \\times cap)\\) \u3002\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig knapsack.py
    def knapsack_dfs_mem(\n    wgt: 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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 or c == 0:\n        return 0\n    # \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][c] != -1:\n        return mem[i][c]\n    # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c:\n        return 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\n    no = knapsack_dfs_mem(wgt, val, mem, i - 1, c)\n    yes = 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\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int 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\n    mem[i][c] = max(no, yes);\n    return mem[i][c];\n}\n
    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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    int 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\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\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\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (weight[i - 1] > c) {\n        return 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\n    int no = KnapsackDFSMem(weight, val, mem, i - 1, c);\n    int 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\n    mem[i][c] = Math.Max(no, yes);\n    return mem[i][c];\n}\n
    knapsack.go
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i-1] > c {\n        return 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\n    no := knapsackDFSMem(wgt, val, mem, i-1, c)\n    yes := knapsackDFSMem(wgt, val, mem, 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\n    mem[i][c] = int(math.Max(float64(no), float64(yes)))\n    return mem[i][c]\n}\n
    knapsack.swift
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunc knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -> Int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][c] != -1 {\n        return mem[i][c]\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c {\n        return knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    let no = knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: c)\n    let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: 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\n    mem[i][c] = max(no, yes)\n    return mem[i][c]\n}\n
    knapsack.js
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction knapsackDFSMem(wgt, val, mem, i, c) {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        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\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n
    knapsack.ts
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfunction knapsackDFSMem(\n    wgt: Array<number>,\n    val: Array<number>,\n    mem: Array<Array<number>>,\n    i: number,\n    c: number\n): number {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i === 0 || c === 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] !== -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    const no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    const yes =\n        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\n    mem[i][c] = Math.max(no, yes);\n    return mem[i][c];\n}\n
    knapsack.dart
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(\n  List<int> wgt,\n  List<int> val,\n  List<List<int>> mem,\n  int i,\n  int c,\n) {\n  // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n  if (i == 0 || c == 0) {\n    return 0;\n  }\n  // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n  if (mem[i][c] != -1) {\n    return mem[i][c];\n  }\n  // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n  if (wgt[i - 1] > c) {\n    return 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\n  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n  int 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\n  mem[i][c] = max(no, yes);\n  return mem[i][c];\n}\n
    knapsack.rs
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfn knapsack_dfs_mem(wgt: &[i32], val: &[i32], mem: &mut Vec<Vec<i32>>, i: usize, c: usize) -> i32 {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if i == 0 || c == 0 {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if mem[i][c] != -1 {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if wgt[i - 1] > c as i32 {\n        return knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c);\n    let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1];\n    // \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    mem[i][c] = std::cmp::max(no, yes);\n    mem[i][c]\n}\n
    knapsack.c
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nint knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);\n    int yes = knapsackDFSMem(wgt, val, memCols, 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\n    mem[i][c] = myMax(no, yes);\n    return mem[i][c];\n}\n
    knapsack.kt
    /* 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22 */\nfun knapsackDFSMem(\n    wgt: IntArray,\n    value: IntArray,\n    mem: Array<IntArray>,\n    i: Int,\n    c: Int\n): Int {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 || c == 0) {\n        return 0\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c]\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return knapsackDFSMem(wgt, value, mem, i - 1, c)\n    }\n    // \u8ba1\u7b97\u4e0d\u653e\u5165\u548c\u653e\u5165\u7269\u54c1 i \u7684\u6700\u5927\u4ef7\u503c\n    val no = knapsackDFSMem(wgt, value, mem, i - 1, c)\n    val yes = knapsackDFSMem(wgt, value, mem, i - 1, c - wgt[i - 1]) + value[i - 1]\n    // \u8bb0\u5f55\u5e76\u8fd4\u56de\u4e24\u79cd\u65b9\u6848\u4e2d\u4ef7\u503c\u66f4\u5927\u7684\u90a3\u4e00\u4e2a\n    mem[i][c] = max(no.toDouble(), yes.toDouble()).toInt()\n    return mem[i][c]\n}\n
    knapsack.rb
    [class]{}-[func]{knapsack_dfs_mem}\n
    knapsack.zig
    // 0-1 \u80cc\u5305\uff1a\u8bb0\u5fc6\u5316\u641c\u7d22\nfn knapsackDFSMem(wgt: []i32, val: []i32, mem: anytype, i: usize, c: usize) i32 {\n    // \u82e5\u5df2\u9009\u5b8c\u6240\u6709\u7269\u54c1\u6216\u80cc\u5305\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u5219\u8fd4\u56de\u4ef7\u503c 0\n    if (i == 0 or c == 0) {\n        return 0;\n    }\n    // \u82e5\u5df2\u6709\u8bb0\u5f55\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (mem[i][c] != -1) {\n        return mem[i][c];\n    }\n    // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u53ea\u80fd\u9009\u62e9\u4e0d\u653e\u5165\u80cc\u5305\n    if (wgt[i - 1] > c) {\n        return 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\n    var no = knapsackDFSMem(wgt, val, mem, i - 1, c);\n    var yes = knapsackDFSMem(wgt, val, mem, i - 1, c - @as(usize, @intCast(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\n    mem[i][c] = @max(no, yes);\n    return mem[i][c];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-19 \u5c55\u793a\u4e86\u5728\u8bb0\u5fc6\u5316\u641c\u7d22\u4e2d\u88ab\u526a\u6389\u7684\u641c\u7d22\u5206\u652f\u3002

    \u56fe 14-19 \u00a0 0-1 \u80cc\u5305\u95ee\u9898\u7684\u8bb0\u5fc6\u5316\u641c\u7d22\u9012\u5f52\u6811

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

    \u52a8\u6001\u89c4\u5212\u5b9e\u8d28\u4e0a\u5c31\u662f\u5728\u72b6\u6001\u8f6c\u79fb\u4e2d\u586b\u5145 \\(dp\\) \u8868\u7684\u8fc7\u7a0b\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig knapsack.py
    def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:\n    \"\"\"0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(wgt)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] > c:\n                # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(vector<int> &wgt, vector<int> &val, int cap) {\n    int n = wgt.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n + 1][cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint KnapsackDP(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n + 1, cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (weight[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n
    knapsack.go
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc knapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        for c := 1; c <= cap; c++ {\n            if wgt[i-1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    knapsack.swift
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc knapsackDP(wgt: [Int], val: [Int], cap: Int) -> Int {\n    let n = wgt.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    knapsack.js
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction knapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array(n + 1)\n        .fill(0)\n        .map(() => Array(cap + 1).fill(0));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    knapsack.ts
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction knapsackDP(\n    wgt: Array<number>,\n    val: Array<number>,\n    cap: number\n): number {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: cap + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    knapsack.dart
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(List<int> wgt, List<int> val, int cap) {\n  int n = wgt.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int c = 1; c <= cap; c++) {\n      if (wgt[i - 1] > c) {\n        // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n        dp[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\n        dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n
    knapsack.rs
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfn knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {\n    let n = wgt.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] > c as i32 {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = std::cmp::max(\n                    dp[i - 1][c],\n                    dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1],\n                );\n            }\n        }\n    }\n    dp[n][cap]\n}\n
    knapsack.c
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint knapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n
    knapsack.kt
    /* 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfun knapsackDP(\n    wgt: IntArray,\n    value: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c].toDouble(), (dp[i - 1][c - wgt[i - 1]] + value[i - 1]).toDouble())\n                    .toInt()\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    knapsack.rb
    [class]{}-[func]{knapsack_dp}\n
    knapsack.zig
    // 0-1 \u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\nfn knapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {\n    comptime var n = wgt.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][cap + 1]i32{[_]i32{0} ** (cap + 1)} ** (n + 1);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..cap + 1) |c| {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = @max(dp[i - 1][c], dp[i - 1][c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 14-20 \u6240\u793a\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u90fd\u7531\u6570\u7ec4 dp \u5927\u5c0f\u51b3\u5b9a\uff0c\u5373 \\(O(n \\times cap)\\) \u3002

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

    \u56fe 14-20 \u00a0 0-1 \u80cc\u5305\u95ee\u9898\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    "},{"location":"chapter_dynamic_programming/knapsack_problem/#4","title":"4. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \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)\\) \u964d\u81f3 \\(O(n)\\) \u3002

    \u8fdb\u4e00\u6b65\u601d\u8003\uff0c\u6211\u4eec\u80fd\u5426\u4ec5\u7528\u4e00\u4e2a\u6570\u7ec4\u5b9e\u73b0\u7a7a\u95f4\u4f18\u5316\u5462\uff1f\u89c2\u5bdf\u53ef\u77e5\uff0c\u6bcf\u4e2a\u72b6\u6001\u90fd\u662f\u7531\u6b63\u4e0a\u65b9\u6216\u5de6\u4e0a\u65b9\u7684\u683c\u5b50\u8f6c\u79fb\u8fc7\u6765\u7684\u3002\u5047\u8bbe\u53ea\u6709\u4e00\u4e2a\u6570\u7ec4\uff0c\u5f53\u5f00\u59cb\u904d\u5386\u7b2c \\(i\\) \u884c\u65f6\uff0c\u8be5\u6570\u7ec4\u5b58\u50a8\u7684\u4ecd\u7136\u662f\u7b2c \\(i-1\\) \u884c\u7684\u72b6\u6001\u3002

    • \u5982\u679c\u91c7\u53d6\u6b63\u5e8f\u904d\u5386\uff0c\u90a3\u4e48\u904d\u5386\u5230 \\(dp[i, j]\\) \u65f6\uff0c\u5de6\u4e0a\u65b9 \\(dp[i-1, 1]\\) ~ \\(dp[i-1, j-1]\\) \u503c\u53ef\u80fd\u5df2\u7ecf\u88ab\u8986\u76d6\uff0c\u6b64\u65f6\u5c31\u65e0\u6cd5\u5f97\u5230\u6b63\u786e\u7684\u72b6\u6001\u8f6c\u79fb\u7ed3\u679c\u3002
    • \u5982\u679c\u91c7\u53d6\u5012\u5e8f\u904d\u5386\uff0c\u5219\u4e0d\u4f1a\u53d1\u751f\u8986\u76d6\u95ee\u9898\uff0c\u72b6\u6001\u8f6c\u79fb\u53ef\u4ee5\u6b63\u786e\u8fdb\u884c\u3002

    \u56fe 14-21 \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\u8bf7\u601d\u8003\u6b63\u5e8f\u904d\u5386\u548c\u5012\u5e8f\u904d\u5386\u7684\u533a\u522b\u3002

    <1><2><3><4><5><6>

    \u56fe 14-21 \u00a0 0-1 \u80cc\u5305\u7684\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u5728\u4ee3\u7801\u5b9e\u73b0\u4e2d\uff0c\u6211\u4eec\u4ec5\u9700\u5c06\u6570\u7ec4 dp \u7684\u7b2c\u4e00\u7ef4 \\(i\\) \u76f4\u63a5\u5220\u9664\uff0c\u5e76\u4e14\u628a\u5185\u5faa\u73af\u66f4\u6539\u4e3a\u5012\u5e8f\u904d\u5386\u5373\u53ef\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig knapsack.py
    def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:\n    \"\"\"0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(wgt)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [0] * (cap + 1)\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        # \u5012\u5e8f\u904d\u5386\n        for c in range(cap, 0, -1):\n            if wgt[i - 1] > c:\n                # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n
    knapsack.cpp
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {\n    int n = wgt.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(cap + 1, 0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (int c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.java
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (int c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.cs
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint KnapsackDPComp(int[] weight, int[] val, int cap) {\n    int n = weight.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (int c = cap; c > 0; c--) {\n            if (weight[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.go
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc knapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, cap+1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        // \u5012\u5e8f\u904d\u5386\n        for c := cap; c >= 1; c-- {\n            if wgt[i-1] <= c {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n
    knapsack.swift
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -> Int {\n    let n = wgt.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: 0, count: cap + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        // \u5012\u5e8f\u904d\u5386\n        for c in (1 ... cap).reversed() {\n            if wgt[i - 1] <= c {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n
    knapsack.js
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction knapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array(cap + 1).fill(0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (let c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.ts
    /* 0-1 \u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction knapsackDPComp(\n    wgt: Array<number>,\n    val: Array<number>,\n    cap: number\n): number {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array(cap + 1).fill(0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (let c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    knapsack.dart
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(List<int> wgt, List<int> val, int cap) {\n  int n = wgt.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(cap + 1, 0);\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    // \u5012\u5e8f\u904d\u5386\n    for (int c = cap; c >= 1; c--) {\n      if (wgt[i - 1] <= c) {\n        // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n
    knapsack.rs
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {\n    let n = wgt.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        // \u5012\u5e8f\u904d\u5386\n        for c in (1..=cap).rev() {\n            if wgt[i - 1] <= c as i32 {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n
    knapsack.c
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(cap + 1, sizeof(int));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        // \u5012\u5e8f\u904d\u5386\n        for (int c = cap; c >= 1; c--) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    knapsack.kt
    /* 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun knapsackDPComp(\n    wgt: IntArray,\n    value: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(cap + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        // \u5012\u5e8f\u904d\u5386\n        for (c in cap downTo 1) {\n            if (wgt[i - 1] <= c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] =\n                    max(dp[c].toDouble(), (dp[c - wgt[i - 1]] + value[i - 1]).toDouble()).toInt()\n            }\n        }\n    }\n    return dp[cap]\n}\n
    knapsack.rb
    [class]{}-[func]{knapsack_dp_comp}\n
    knapsack.zig
    // 0-1 \u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn knapsackDPComp(wgt: []i32, val: []i32, comptime cap: usize) i32 {\n    var n = wgt.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** (cap + 1);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        // \u5012\u5e8f\u904d\u5386\n        var c = cap;\n        while (c > 0) : (c -= 1) {\n            if (wgt[i - 1] < c) {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = @max(dp[c], dp[c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/summary/","title":"14.7 \u00a0 \u5c0f\u7ed3","text":"
    • \u52a8\u6001\u89c4\u5212\u5bf9\u95ee\u9898\u8fdb\u884c\u5206\u89e3\uff0c\u5e76\u901a\u8fc7\u5b58\u50a8\u5b50\u95ee\u9898\u7684\u89e3\u6765\u89c4\u907f\u91cd\u590d\u8ba1\u7b97\uff0c\u63d0\u9ad8\u8ba1\u7b97\u6548\u7387\u3002
    • \u4e0d\u8003\u8651\u65f6\u95f4\u7684\u524d\u63d0\u4e0b\uff0c\u6240\u6709\u52a8\u6001\u89c4\u5212\u95ee\u9898\u90fd\u53ef\u4ee5\u7528\u56de\u6eaf\uff08\u66b4\u529b\u641c\u7d22\uff09\u8fdb\u884c\u6c42\u89e3\uff0c\u4f46\u9012\u5f52\u6811\u4e2d\u5b58\u5728\u5927\u91cf\u7684\u91cd\u53e0\u5b50\u95ee\u9898\uff0c\u6548\u7387\u6781\u4f4e\u3002\u901a\u8fc7\u5f15\u5165\u8bb0\u5fc6\u5316\u5217\u8868\uff0c\u53ef\u4ee5\u5b58\u50a8\u6240\u6709\u8ba1\u7b97\u8fc7\u7684\u5b50\u95ee\u9898\u7684\u89e3\uff0c\u4ece\u800c\u4fdd\u8bc1\u91cd\u53e0\u5b50\u95ee\u9898\u53ea\u88ab\u8ba1\u7b97\u4e00\u6b21\u3002
    • \u8bb0\u5fc6\u5316\u641c\u7d22\u662f\u4e00\u79cd\u4ece\u9876\u81f3\u5e95\u7684\u9012\u5f52\u5f0f\u89e3\u6cd5\uff0c\u800c\u4e0e\u4e4b\u5bf9\u5e94\u7684\u52a8\u6001\u89c4\u5212\u662f\u4e00\u79cd\u4ece\u5e95\u81f3\u9876\u7684\u9012\u63a8\u5f0f\u89e3\u6cd5\uff0c\u5176\u5982\u540c\u201c\u586b\u5199\u8868\u683c\u201d\u4e00\u6837\u3002\u7531\u4e8e\u5f53\u524d\u72b6\u6001\u4ec5\u4f9d\u8d56\u67d0\u4e9b\u5c40\u90e8\u72b6\u6001\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u6d88\u9664 \\(dp\\) \u8868\u7684\u4e00\u4e2a\u7ef4\u5ea6\uff0c\u4ece\u800c\u964d\u4f4e\u7a7a\u95f4\u590d\u6742\u5ea6\u3002
    • \u5b50\u95ee\u9898\u5206\u89e3\u662f\u4e00\u79cd\u901a\u7528\u7684\u7b97\u6cd5\u601d\u8def\uff0c\u5728\u5206\u6cbb\u3001\u52a8\u6001\u89c4\u5212\u3001\u56de\u6eaf\u4e2d\u5177\u6709\u4e0d\u540c\u7684\u6027\u8d28\u3002
    • \u52a8\u6001\u89c4\u5212\u95ee\u9898\u6709\u4e09\u5927\u7279\u6027\uff1a\u91cd\u53e0\u5b50\u95ee\u9898\u3001\u6700\u4f18\u5b50\u7ed3\u6784\u3001\u65e0\u540e\u6548\u6027\u3002
    • \u5982\u679c\u539f\u95ee\u9898\u7684\u6700\u4f18\u89e3\u53ef\u4ee5\u4ece\u5b50\u95ee\u9898\u7684\u6700\u4f18\u89e3\u6784\u5efa\u5f97\u6765\uff0c\u5219\u5b83\u5c31\u5177\u6709\u6700\u4f18\u5b50\u7ed3\u6784\u3002
    • \u65e0\u540e\u6548\u6027\u6307\u5bf9\u4e8e\u4e00\u4e2a\u72b6\u6001\uff0c\u5176\u672a\u6765\u53d1\u5c55\u53ea\u4e0e\u8be5\u72b6\u6001\u6709\u5173\uff0c\u800c\u4e0e\u8fc7\u53bb\u7ecf\u5386\u7684\u6240\u6709\u72b6\u6001\u65e0\u5173\u3002\u8bb8\u591a\u7ec4\u5408\u4f18\u5316\u95ee\u9898\u4e0d\u5177\u6709\u65e0\u540e\u6548\u6027\uff0c\u65e0\u6cd5\u4f7f\u7528\u52a8\u6001\u89c4\u5212\u5feb\u901f\u6c42\u89e3\u3002

    \u80cc\u5305\u95ee\u9898

    • \u80cc\u5305\u95ee\u9898\u662f\u6700\u5178\u578b\u7684\u52a8\u6001\u89c4\u5212\u95ee\u9898\u4e4b\u4e00\uff0c\u5177\u6709 0-1 \u80cc\u5305\u3001\u5b8c\u5168\u80cc\u5305\u3001\u591a\u91cd\u80cc\u5305\u7b49\u53d8\u79cd\u3002
    • 0-1 \u80cc\u5305\u7684\u72b6\u6001\u5b9a\u4e49\u4e3a\u524d \\(i\\) \u4e2a\u7269\u54c1\u5728\u5269\u4f59\u5bb9\u91cf\u4e3a \\(c\\) \u7684\u80cc\u5305\u4e2d\u7684\u6700\u5927\u4ef7\u503c\u3002\u6839\u636e\u4e0d\u653e\u5165\u80cc\u5305\u548c\u653e\u5165\u80cc\u5305\u4e24\u79cd\u51b3\u7b56\uff0c\u53ef\u5f97\u5230\u6700\u4f18\u5b50\u7ed3\u6784\uff0c\u5e76\u6784\u5efa\u51fa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u3002\u5728\u7a7a\u95f4\u4f18\u5316\u4e2d\uff0c\u7531\u4e8e\u6bcf\u4e2a\u72b6\u6001\u4f9d\u8d56\u6b63\u4e0a\u65b9\u548c\u5de6\u4e0a\u65b9\u7684\u72b6\u6001\uff0c\u56e0\u6b64\u9700\u8981\u5012\u5e8f\u904d\u5386\u5217\u8868\uff0c\u907f\u514d\u5de6\u4e0a\u65b9\u72b6\u6001\u88ab\u8986\u76d6\u3002
    • \u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u6bcf\u79cd\u7269\u54c1\u7684\u9009\u53d6\u6570\u91cf\u65e0\u9650\u5236\uff0c\u56e0\u6b64\u9009\u62e9\u653e\u5165\u7269\u54c1\u7684\u72b6\u6001\u8f6c\u79fb\u4e0e 0-1 \u80cc\u5305\u95ee\u9898\u4e0d\u540c\u3002\u7531\u4e8e\u72b6\u6001\u4f9d\u8d56\u6b63\u4e0a\u65b9\u548c\u6b63\u5de6\u65b9\u7684\u72b6\u6001\uff0c\u56e0\u6b64\u5728\u7a7a\u95f4\u4f18\u5316\u4e2d\u5e94\u5f53\u6b63\u5e8f\u904d\u5386\u3002
    • \u96f6\u94b1\u5151\u6362\u95ee\u9898\u662f\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u4e00\u4e2a\u53d8\u79cd\u3002\u5b83\u4ece\u6c42\u201c\u6700\u5927\u201d\u4ef7\u503c\u53d8\u4e3a\u6c42\u201c\u6700\u5c0f\u201d\u786c\u5e01\u6570\u91cf\uff0c\u56e0\u6b64\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e2d\u7684 \\(\\max()\\) \u5e94\u6539\u4e3a \\(\\min()\\) \u3002\u4ece\u8ffd\u6c42\u201c\u4e0d\u8d85\u8fc7\u201d\u80cc\u5305\u5bb9\u91cf\u5230\u8ffd\u6c42\u201c\u6070\u597d\u201d\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u56e0\u6b64\u4f7f\u7528 \\(amt + 1\\) \u6765\u8868\u793a\u201c\u65e0\u6cd5\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u201d\u7684\u65e0\u6548\u89e3\u3002
    • \u96f6\u94b1\u5151\u6362\u95ee\u9898 II \u4ece\u6c42\u201c\u6700\u5c11\u786c\u5e01\u6570\u91cf\u201d\u6539\u4e3a\u6c42\u201c\u786c\u5e01\u7ec4\u5408\u6570\u91cf\u201d\uff0c\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u76f8\u5e94\u5730\u4ece \\(\\min()\\) \u6539\u4e3a\u6c42\u548c\u8fd0\u7b97\u7b26\u3002

    \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898

    • \u7f16\u8f91\u8ddd\u79bb\uff08Levenshtein \u8ddd\u79bb\uff09\u7528\u4e8e\u8861\u91cf\u4e24\u4e2a\u5b57\u7b26\u4e32\u4e4b\u95f4\u7684\u76f8\u4f3c\u5ea6\uff0c\u5176\u5b9a\u4e49\u4e3a\u4ece\u4e00\u4e2a\u5b57\u7b26\u4e32\u5230\u53e6\u4e00\u4e2a\u5b57\u7b26\u4e32\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\uff0c\u7f16\u8f91\u64cd\u4f5c\u5305\u62ec\u6dfb\u52a0\u3001\u5220\u9664\u3001\u66ff\u6362\u3002
    • \u7f16\u8f91\u8ddd\u79bb\u95ee\u9898\u7684\u72b6\u6001\u5b9a\u4e49\u4e3a\u5c06 \\(s\\) \u7684\u524d \\(i\\) \u4e2a\u5b57\u7b26\u66f4\u6539\u4e3a \\(t\\) \u7684\u524d \\(j\\) \u4e2a\u5b57\u7b26\u6240\u9700\u7684\u6700\u5c11\u7f16\u8f91\u6b65\u6570\u3002\u5f53 \\(s[i] \\ne t[j]\\) \u65f6\uff0c\u5177\u6709\u4e09\u79cd\u51b3\u7b56\uff1a\u6dfb\u52a0\u3001\u5220\u9664\u3001\u66ff\u6362\uff0c\u5b83\u4eec\u90fd\u6709\u76f8\u5e94\u7684\u5269\u4f59\u5b50\u95ee\u9898\u3002\u636e\u6b64\u4fbf\u53ef\u4ee5\u627e\u51fa\u6700\u4f18\u5b50\u7ed3\u6784\u4e0e\u6784\u5efa\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u3002\u800c\u5f53 \\(s[i] = t[j]\\) \u65f6\uff0c\u65e0\u987b\u7f16\u8f91\u5f53\u524d\u5b57\u7b26\u3002
    • \u5728\u7f16\u8f91\u8ddd\u79bb\u4e2d\uff0c\u72b6\u6001\u4f9d\u8d56\u5176\u6b63\u4e0a\u65b9\u3001\u6b63\u5de6\u65b9\u3001\u5de6\u4e0a\u65b9\u7684\u72b6\u6001\uff0c\u56e0\u6b64\u7a7a\u95f4\u4f18\u5316\u540e\u6b63\u5e8f\u6216\u5012\u5e8f\u904d\u5386\u90fd\u65e0\u6cd5\u6b63\u786e\u5730\u8fdb\u884c\u72b6\u6001\u8f6c\u79fb\u3002\u4e3a\u6b64\uff0c\u6211\u4eec\u5229\u7528\u4e00\u4e2a\u53d8\u91cf\u6682\u5b58\u5de6\u4e0a\u65b9\u72b6\u6001\uff0c\u4ece\u800c\u8f6c\u5316\u5230\u4e0e\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7b49\u4ef7\u7684\u60c5\u51b5\uff0c\u53ef\u4ee5\u5728\u7a7a\u95f4\u4f18\u5316\u540e\u8fdb\u884c\u6b63\u5e8f\u904d\u5386\u3002
    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/","title":"14.5 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898","text":"

    \u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u5148\u6c42\u89e3\u53e6\u4e00\u4e2a\u5e38\u89c1\u7684\u80cc\u5305\u95ee\u9898\uff1a\u5b8c\u5168\u80cc\u5305\uff0c\u518d\u4e86\u89e3\u5b83\u7684\u4e00\u79cd\u7279\u4f8b\uff1a\u96f6\u94b1\u5151\u6362\u3002

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1451","title":"14.5.1 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898","text":"

    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\u548c\u4e00\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\u3002\u6bcf\u4e2a\u7269\u54c1\u53ef\u4ee5\u91cd\u590d\u9009\u53d6\uff0c\u95ee\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u80fd\u653e\u5165\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002\u793a\u4f8b\u5982\u56fe 14-22 \u6240\u793a\u3002

    \u56fe 14-22 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1","title":"1. \u00a0 \u52a8\u6001\u89c4\u5212\u601d\u8def","text":"

    \u5b8c\u5168\u80cc\u5305\u95ee\u9898\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\u95ee\u9898\u4e2d\uff0c\u6bcf\u79cd\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\u3002
    • \u5728\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u4e2d\uff0c\u6bcf\u79cd\u7269\u54c1\u7684\u6570\u91cf\u662f\u65e0\u9650\u7684\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\u3002

    \u5728\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u89c4\u5b9a\u4e0b\uff0c\u72b6\u6001 \\([i, c]\\) \u7684\u53d8\u5316\u5206\u4e3a\u4e24\u79cd\u60c5\u51b5\u3002

    • \u4e0d\u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u4e0e 0-1 \u80cc\u5305\u95ee\u9898\u76f8\u540c\uff0c\u8f6c\u79fb\u81f3 \\([i-1, c]\\) \u3002
    • \u653e\u5165\u7269\u54c1 \\(i\\) \uff1a\u4e0e 0-1 \u80cc\u5305\u95ee\u9898\u4e0d\u540c\uff0c\u8f6c\u79fb\u81f3 \\([i, c-wgt[i-1]]\\) \u3002

    \u4ece\u800c\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]) \\]"},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5bf9\u6bd4\u4e24\u9053\u9898\u76ee\u7684\u4ee3\u7801\uff0c\u72b6\u6001\u8f6c\u79fb\u4e2d\u6709\u4e00\u5904\u4ece \\(i-1\\) \u53d8\u4e3a \\(i\\) \uff0c\u5176\u4f59\u5b8c\u5168\u4e00\u81f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    n = len(wgt)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * (cap + 1) for _ in range(n + 1)]\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        for c in range(1, cap + 1):\n            if wgt[i - 1] > c:\n                # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n    return dp[n][cap]\n
    unbounded_knapsack.cpp
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {\n    int n = wgt.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n + 1, vector<int>(cap + 1, 0));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.java
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n + 1][cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.cs
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n + 1, cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n, cap];\n}\n
    unbounded_knapsack.go
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc unboundedKnapsackDP(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, cap+1)\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        for c := 1; c <= cap; c++ {\n            if wgt[i-1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    unbounded_knapsack.swift
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -> Int {\n    let n = wgt.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    unbounded_knapsack.js
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction unboundedKnapsackDP(wgt, val, cap) {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: cap + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.ts
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction unboundedKnapsackDP(\n    wgt: Array<number>,\n    val: Array<number>,\n    cap: number\n): number {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: cap + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = Math.max(\n                    dp[i - 1][c],\n                    dp[i][c - wgt[i - 1]] + val[i - 1]\n                );\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.dart
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(List<int> wgt, List<int> val, int cap) {\n  int n = wgt.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int c = 1; c <= cap; c++) {\n      if (wgt[i - 1] > c) {\n        // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n        dp[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\n        dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[n][cap];\n}\n
    unbounded_knapsack.rs
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfn unbounded_knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {\n    let n = wgt.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; cap + 1]; n + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] > c as i32 {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    unbounded_knapsack.c
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(cap + 1, sizeof(int));\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[n][cap];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    return res;\n}\n
    unbounded_knapsack.kt
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212 */\nfun unboundedKnapsackDP(\n    wgt: IntArray,\n    value: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n + 1) { IntArray(cap + 1) }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = max(dp[i - 1][c].toDouble(), (dp[i][c - wgt[i - 1]] + value[i - 1]).toDouble())\n                    .toInt()\n            }\n        }\n    }\n    return dp[n][cap]\n}\n
    unbounded_knapsack.rb
    [class]{}-[func]{unbounded_knapsack_dp}\n
    unbounded_knapsack.zig
    // \u5b8c\u5168\u80cc\u5305\uff1a\u52a8\u6001\u89c4\u5212\nfn unboundedKnapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {\n    comptime var n = wgt.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][cap + 1]i32{[_]i32{0} ** (cap + 1)} ** (n + 1);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..cap + 1) |c| {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[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\n                dp[i][c] = @max(dp[i - 1][c], dp[i][c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);\n            }\n        }\n    }\n    return dp[n][cap];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3","title":"3. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7531\u4e8e\u5f53\u524d\u72b6\u6001\u662f\u4ece\u5de6\u8fb9\u548c\u4e0a\u8fb9\u7684\u72b6\u6001\u8f6c\u79fb\u800c\u6765\u7684\uff0c\u56e0\u6b64\u7a7a\u95f4\u4f18\u5316\u540e\u5e94\u8be5\u5bf9 \\(dp\\) \u8868\u4e2d\u7684\u6bcf\u4e00\u884c\u8fdb\u884c\u6b63\u5e8f\u904d\u5386\u3002

    \u8fd9\u4e2a\u904d\u5386\u987a\u5e8f\u4e0e 0-1 \u80cc\u5305\u6b63\u597d\u76f8\u53cd\u3002\u8bf7\u501f\u52a9\u56fe 14-23 \u6765\u7406\u89e3\u4e24\u8005\u7684\u533a\u522b\u3002

    <1><2><3><4><5><6>

    \u56fe 14-23 \u00a0 \u5b8c\u5168\u80cc\u5305\u95ee\u9898\u5728\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    \u4ee3\u7801\u5b9e\u73b0\u6bd4\u8f83\u7b80\u5355\uff0c\u4ec5\u9700\u5c06\u6570\u7ec4 dp \u7684\u7b2c\u4e00\u7ef4\u5220\u9664\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig unbounded_knapsack.py
    def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:\n    \"\"\"\u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(wgt)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [0] * (cap + 1)\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        # \u6b63\u5e8f\u904d\u5386\n        for c in range(1, cap + 1):\n            if wgt[i - 1] > c:\n                # \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n    return dp[cap]\n
    unbounded_knapsack.cpp
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {\n    int n = wgt.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(cap + 1, 0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.java
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.cs
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {\n    int n = wgt.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.go
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc unboundedKnapsackDPComp(wgt, val []int, cap int) int {\n    n := len(wgt)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, cap+1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        for c := 1; c <= cap; c++ {\n            if wgt[i-1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))\n            }\n        }\n    }\n    return dp[cap]\n}\n
    unbounded_knapsack.swift
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -> Int {\n    let n = wgt.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: 0, count: cap + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for c in 1 ... cap {\n            if wgt[i - 1] > c {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1])\n            }\n        }\n    }\n    return dp[cap]\n}\n
    unbounded_knapsack.js
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction unboundedKnapsackDPComp(wgt, val, cap) {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: cap + 1 }, () => 0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.ts
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction unboundedKnapsackDPComp(\n    wgt: Array<number>,\n    val: Array<number>,\n    cap: number\n): number {\n    const n = wgt.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: cap + 1 }, () => 0);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    unbounded_knapsack.dart
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(List<int> wgt, List<int> val, int cap) {\n  int n = wgt.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(cap + 1, 0);\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int c = 1; c <= cap; c++) {\n      if (wgt[i - 1] > c) {\n        // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n        dp[c] = dp[c];\n      } else {\n        // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n      }\n    }\n  }\n  return dp[cap];\n}\n
    unbounded_knapsack.rs
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn unbounded_knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {\n    let n = wgt.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; cap + 1];\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for c in 1..=cap {\n            if wgt[i - 1] > c as i32 {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);\n            }\n        }\n    }\n    dp[cap]\n}\n
    unbounded_knapsack.c
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {\n    int n = wgtSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(cap + 1, sizeof(int));\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int c = 1; c <= cap; c++) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);\n            }\n        }\n    }\n    int res = dp[cap];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    unbounded_knapsack.kt
    /* \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun unboundedKnapsackDPComp(\n    wgt: IntArray,\n    value: IntArray,\n    cap: Int\n): Int {\n    val n = wgt.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(cap + 1)\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (c in 1..cap) {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] =\n                    max(dp[c].toDouble(), (dp[c - wgt[i - 1]] + value[i - 1]).toDouble()).toInt()\n            }\n        }\n    }\n    return dp[cap]\n}\n
    unbounded_knapsack.rb
    [class]{}-[func]{unbounded_knapsack_dp_comp}\n
    unbounded_knapsack.zig
    // \u5b8c\u5168\u80cc\u5305\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn unboundedKnapsackDPComp(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {\n    comptime var n = wgt.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** (cap + 1);\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..cap + 1) |c| {\n            if (wgt[i - 1] > c) {\n                // \u82e5\u8d85\u8fc7\u80cc\u5305\u5bb9\u91cf\uff0c\u5219\u4e0d\u9009\u7269\u54c1 i\n                dp[c] = dp[c];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u7269\u54c1 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5927\u503c\n                dp[c] = @max(dp[c], dp[c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);\n            }\n        }\n    }\n    return dp[cap];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1452","title":"14.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\u53d8\u79cd\uff0c\u4f8b\u5982\u96f6\u94b1\u5151\u6362\u95ee\u9898\u3002

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u786c\u5e01\uff0c\u7b2c \\(i\\) \u79cd\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\u80fd\u591f\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u7684\u6700\u5c11\u786c\u5e01\u6570\u91cf\u3002\u5982\u679c\u65e0\u6cd5\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002\u793a\u4f8b\u5982\u56fe 14-24 \u6240\u793a\u3002

    \u56fe 14-24 \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_1","title":"1. \u00a0 \u52a8\u6001\u89c4\u5212\u601d\u8def","text":"

    \u96f6\u94b1\u5151\u6362\u53ef\u4ee5\u770b\u4f5c\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\u3002

    • \u4e24\u9053\u9898\u53ef\u4ee5\u76f8\u4e92\u8f6c\u6362\uff0c\u201c\u7269\u54c1\u201d\u5bf9\u5e94\u201c\u786c\u5e01\u201d\u3001\u201c\u7269\u54c1\u91cd\u91cf\u201d\u5bf9\u5e94\u201c\u786c\u5e01\u9762\u503c\u201d\u3001\u201c\u80cc\u5305\u5bb9\u91cf\u201d\u5bf9\u5e94\u201c\u76ee\u6807\u91d1\u989d\u201d\u3002
    • \u4f18\u5316\u76ee\u6807\u76f8\u53cd\uff0c\u5b8c\u5168\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\u3002
    • \u5b8c\u5168\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\u3002

    \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\\) \u79cd\u786c\u5e01\u80fd\u591f\u51d1\u51fa\u91d1\u989d \\(a\\) \u7684\u6700\u5c11\u786c\u5e01\u6570\u91cf\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

    \u672c\u9898\u4e0e\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u7684\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u5b58\u5728\u4ee5\u4e0b\u4e24\u70b9\u5dee\u5f02\u3002

    • \u672c\u9898\u8981\u6c42\u6700\u5c0f\u503c\uff0c\u56e0\u6b64\u9700\u5c06\u8fd0\u7b97\u7b26 \\(\\max()\\) \u66f4\u6539\u4e3a \\(\\min()\\) \u3002
    • \u4f18\u5316\u4e3b\u4f53\u662f\u786c\u5e01\u6570\u91cf\u800c\u975e\u5546\u54c1\u4ef7\u503c\uff0c\u56e0\u6b64\u5728\u9009\u4e2d\u786c\u5e01\u65f6\u6267\u884c \\(+1\\) \u5373\u53ef\u3002
    \\[ 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\u6570\u91cf\u4e3a \\(0\\) \uff0c\u5373\u9996\u5217\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\u9996\u884c\u6240\u6709 \\(dp[0, a]\\) \u90fd\u7b49\u4e8e \\(+ \\infty\\) \u3002

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_1","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5927\u591a\u6570\u7f16\u7a0b\u8bed\u8a00\u5e76\u672a\u63d0\u4f9b \\(+ \\infty\\) \u53d8\u91cf\uff0c\u53ea\u80fd\u4f7f\u7528\u6574\u578b int \u7684\u6700\u5927\u503c\u6765\u4ee3\u66ff\u3002\u800c\u8fd9\u53c8\u4f1a\u5bfc\u81f4\u5927\u6570\u8d8a\u754c\uff1a\u72b6\u6001\u8f6c\u79fb\u65b9\u7a0b\u4e2d\u7684 \\(+ 1\\) \u64cd\u4f5c\u53ef\u80fd\u53d1\u751f\u6ea2\u51fa\u3002

    \u4e3a\u6b64\uff0c\u6211\u4eec\u91c7\u7528\u6570\u5b57 \\(amt + 1\\) \u6765\u8868\u793a\u65e0\u6548\u89e3\uff0c\u56e0\u4e3a\u51d1\u51fa \\(amt\\) \u7684\u786c\u5e01\u6570\u91cf\u6700\u591a\u4e3a \\(amt\\) \u3002\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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig coin_change.py
    def coin_change_dp(coins: list[int], amt: int) -> int:\n    \"\"\"\u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for a in range(1, amt + 1):\n        dp[0][a] = MAX\n    # \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] > a:\n                # \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n    return dp[n][amt] if dp[n][amt] != MAX else -1\n
    coin_change.cpp
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(vector<int> &coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n
    coin_change.java
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n + 1][amt + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n
    coin_change.cs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint CoinChangeDP(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n + 1, amt + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int a = 1; a <= amt; a++) {\n        dp[0, a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n, amt] != MAX ? dp[n, amt] : -1;\n}\n
    coin_change.go
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeDP(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for a := 1; a <= amt; a++ {\n        dp[0][a] = max\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i <= n; i++ {\n        for a := 1; a <= amt; a++ {\n            if coins[i-1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt]\n    }\n    return -1\n}\n
    coin_change.swift
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeDP(coins: [Int], amt: Int) -> Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for a in 1 ... amt {\n        dp[0][a] = MAX\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[n][amt] != MAX ? dp[n][amt] : -1\n}\n
    coin_change.js
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeDP(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: amt + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (let a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n
    coin_change.ts
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeDP(coins: Array<number>, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: amt + 1 }, () => 0)\n    );\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (let a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[n][amt] !== MAX ? dp[n][amt] : -1;\n}\n
    coin_change.dart
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(List<int> coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n  for (int a = 1; a <= amt; a++) {\n    dp[0][a] = MAX;\n  }\n  // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n  for (int i = 1; i <= n; i++) {\n    for (int a = 1; a <= amt; a++) {\n      if (coins[i - 1] > a) {\n        // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n        dp[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\n        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[n][amt] != MAX ? dp[n][amt] : -1;\n}\n
    coin_change.rs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfn coin_change_dp(coins: &[i32], amt: usize) -> i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for a in 1..=amt {\n        dp[0][a] = max;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] > a as i32 {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[n][amt] != max {\n        return dp[n][amt] as i32;\n    } else {\n        -1\n    }\n}\n
    coin_change.c
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (int a = 1; a <= amt; a++) {\n        dp[0][a] = MAX;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[n][amt] != MAX ? dp[n][amt] : -1;\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n
    coin_change.kt
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfun coinChangeDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (a in 1..amt) {\n        dp[0][a] = MAX\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = min(dp[i - 1][a].toDouble(), (dp[i][a - coins[i - 1]] + 1).toDouble())\n                    .toInt()\n            }\n        }\n    }\n    return if (dp[n][amt] != MAX) dp[n][amt] else -1\n}\n
    coin_change.rb
    [class]{}-[func]{coin_change_dp}\n
    coin_change.zig
    // \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212\nfn coinChangeDP(comptime coins: []i32, comptime amt: usize) i32 {\n    comptime var n = coins.len;\n    comptime var max = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][amt + 1]i32{[_]i32{0} ** (amt + 1)} ** (n + 1);\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u9996\u884c\u9996\u5217\n    for (1..amt + 1) |a| {\n        dp[0][a] = max;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for (1..n + 1) |i| {\n        for (1..amt + 1) |a| {\n            if (coins[i - 1] > @as(i32, @intCast(a))) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = @min(dp[i - 1][a], dp[i][a - @as(usize, @intCast(coins[i - 1]))] + 1);\n            }\n        }\n    }\n    if (dp[n][amt] != max) {\n        return @intCast(dp[n][amt]);\n    } else {\n        return -1;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 14-25 \u5c55\u793a\u4e86\u96f6\u94b1\u5151\u6362\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b\uff0c\u548c\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u975e\u5e38\u76f8\u4f3c\u3002

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

    \u56fe 14-25 \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898\u7684\u52a8\u6001\u89c4\u5212\u8fc7\u7a0b

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_1","title":"3. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u96f6\u94b1\u5151\u6362\u7684\u7a7a\u95f4\u4f18\u5316\u7684\u5904\u7406\u65b9\u5f0f\u548c\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u4e00\u81f4\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig coin_change.py
    def coin_change_dp_comp(coins: list[int], amt: int) -> int:\n    \"\"\"\u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(coins)\n    MAX = amt + 1\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [MAX] * (amt + 1)\n    dp[0] = 0\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        # \u6b63\u5e8f\u904d\u5386\n        for a in range(1, amt + 1):\n            if coins[i - 1] > a:\n                # \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n    return dp[amt] if dp[amt] != MAX else -1\n
    coin_change.cpp
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(vector<int> &coins, int amt) {\n    int n = coins.size();\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(amt + 1, MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.java
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[amt + 1];\n    Arrays.fill(dp, MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.cs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint CoinChangeDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[amt + 1];\n    Array.Fill(dp, MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.go
    /* \u96f6\u94b1\u5151\u6362\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeDPComp(coins []int, amt int) int {\n    n := len(coins)\n    max := amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, amt+1)\n    for i := 1; i <= amt; i++ {\n        dp[i] = max\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        // \u5012\u5e8f\u904d\u5386\n        for a := 1; a <= amt; a++ {\n            if coins[i-1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt]\n    }\n    return -1\n}\n
    coin_change.swift
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeDPComp(coins: [Int], amt: Int) -> Int {\n    let n = coins.count\n    let MAX = amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: MAX, count: amt + 1)\n    dp[0] = 0\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)\n            }\n        }\n    }\n    return dp[amt] != MAX ? dp[amt] : -1\n}\n
    coin_change.js
    /* \u96f6\u94b1\u5151\u6362\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeDPComp(coins, amt) {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: amt + 1 }, () => MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n
    coin_change.ts
    /* \u96f6\u94b1\u5151\u6362\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeDPComp(coins: Array<number>, amt: number): number {\n    const n = coins.length;\n    const MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: amt + 1 }, () => MAX);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    return dp[amt] !== MAX ? dp[amt] : -1;\n}\n
    coin_change.dart
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(List<int> coins, int amt) {\n  int n = coins.length;\n  int MAX = amt + 1;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(amt + 1, MAX);\n  dp[0] = 0;\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int a = 1; a <= amt; a++) {\n      if (coins[i - 1] > a) {\n        // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n        dp[a] = dp[a];\n      } else {\n        // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);\n      }\n    }\n  }\n  return dp[amt] != MAX ? dp[amt] : -1;\n}\n
    coin_change.rs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn coin_change_dp_comp(coins: &[i32], amt: usize) -> i32 {\n    let n = coins.len();\n    let max = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; amt + 1];\n    dp.fill(max);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] > a as i32 {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);\n            }\n        }\n    }\n    if dp[amt] != max {\n        return dp[amt] as i32;\n    } else {\n        -1\n    }\n}\n
    coin_change.c
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    int MAX = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);\n            }\n        }\n    }\n    int res = dp[amt] != MAX ? dp[amt] : -1;\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    coin_change.kt
    /* \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun coinChangeDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    val MAX = amt + 1\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(amt + 1)\n    Arrays.fill(dp, MAX)\n    dp[0] = 0\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = min(dp[a].toDouble(), (dp[a - coins[i - 1]] + 1).toDouble()).toInt()\n            }\n        }\n    }\n    return if (dp[amt] != MAX) dp[amt] else -1\n}\n
    coin_change.rb
    [class]{}-[func]{coin_change_dp_comp}\n
    coin_change.zig
    // \u96f6\u94b1\u5151\u6362\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn coinChangeDPComp(comptime coins: []i32, comptime amt: usize) i32 {\n    comptime var n = coins.len;\n    comptime var max = amt + 1;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** (amt + 1);\n    @memset(&dp, max);\n    dp[0] = 0;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..amt + 1) |a| {\n            if (coins[i - 1] > @as(i32, @intCast(a))) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = @min(dp[a], dp[a - @as(usize, @intCast(coins[i - 1]))] + 1);\n            }\n        }\n    }\n    if (dp[amt] != max) {\n        return @intCast(dp[amt]);\n    } else {\n        return -1;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1453-ii","title":"14.5.3 \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898 II","text":"

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u786c\u5e01\uff0c\u7b2c \\(i\\) \u79cd\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\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u7684\u786c\u5e01\u7ec4\u5408\u6570\u91cf\u3002\u793a\u4f8b\u5982\u56fe 14-26 \u6240\u793a\u3002

    \u56fe 14-26 \u00a0 \u96f6\u94b1\u5151\u6362\u95ee\u9898 II \u7684\u793a\u4f8b\u6570\u636e

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#1_2","title":"1. \u00a0 \u52a8\u6001\u89c4\u5212\u601d\u8def","text":"

    \u76f8\u6bd4\u4e8e\u4e0a\u4e00\u9898\uff0c\u672c\u9898\u76ee\u6807\u662f\u6c42\u7ec4\u5408\u6570\u91cf\uff0c\u56e0\u6b64\u5b50\u95ee\u9898\u53d8\u4e3a\uff1a\u524d \\(i\\) \u79cd\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\u987b\u9009\u62e9\u4efb\u4f55\u786c\u5e01\u5373\u53ef\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u56e0\u6b64\u5e94\u5c06\u9996\u5217\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\u9996\u884c\u6240\u6709 \\(dp[0, a]\\) \u90fd\u7b49\u4e8e \\(0\\) \u3002

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#2_2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    n = len(coins)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [[0] * (amt + 1) for _ in range(n + 1)]\n    # \u521d\u59cb\u5316\u9996\u5217\n    for i in range(n + 1):\n        dp[i][0] = 1\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        for a in range(1, amt + 1):\n            if coins[i - 1] > a:\n                # \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n    return dp[n][amt]\n
    coin_change_ii.cpp
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(vector<int> &coins, int amt) {\n    int n = coins.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<vector<int>> dp(n + 1, vector<int>(amt + 1, 0));\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (int i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    coin_change_ii.java
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(int[] coins, int amt) {\n    int n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[][] dp = new int[n + 1][amt + 1];\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (int i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    coin_change_ii.cs
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint CoinChangeIIDP(int[] coins, int amt) {\n    int n = coins.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[,] dp = new int[n + 1, amt + 1];\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (int i = 0; i <= n; i++) {\n        dp[i, 0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i, a] = dp[i - 1, a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n, amt];\n}\n
    coin_change_ii.go
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeIIDP(coins []int, amt int) int {\n    n := len(coins)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([][]int, n+1)\n    for i := 0; i <= n; i++ {\n        dp[i] = make([]int, amt+1)\n    }\n    // \u521d\u59cb\u5316\u9996\u5217\n    for i := 0; i <= n; i++ {\n        dp[i][0] = 1\n    }\n    // \u72b6\u6001\u8f6c\u79fb\uff1a\u5176\u4f59\u884c\u548c\u5217\n    for i := 1; i <= n; i++ {\n        for a := 1; a <= amt; a++ {\n            if coins[i-1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i-1][a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n
    coin_change_ii.swift
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeIIDP(coins: [Int], amt: Int) -> Int {\n    let n = coins.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)\n    // \u521d\u59cb\u5316\u9996\u5217\n    for i in 0 ... n {\n        dp[i][0] = 1\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n
    coin_change_ii.js
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeIIDP(coins, amt) {\n    const n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: amt + 1 }, () => 0)\n    );\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (let i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    coin_change_ii.ts
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeIIDP(coins: Array<number>, amt: number): number {\n    const n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: n + 1 }, () =>\n        Array.from({ length: amt + 1 }, () => 0)\n    );\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (let i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    coin_change_ii.dart
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(List<int> coins, int amt) {\n  int n = coins.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));\n  // \u521d\u59cb\u5316\u9996\u5217\n  for (int i = 0; i <= n; i++) {\n    dp[i][0] = 1;\n  }\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int a = 1; a <= amt; a++) {\n      if (coins[i - 1] > a) {\n        // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n        dp[i][a] = dp[i - 1][a];\n      } else {\n        // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[n][amt];\n}\n
    coin_change_ii.rs
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfn coin_change_ii_dp(coins: &[i32], amt: usize) -> i32 {\n    let n = coins.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![vec![0; amt + 1]; n + 1];\n    // \u521d\u59cb\u5316\u9996\u5217\n    for i in 0..=n {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] > a as i32 {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[n][amt]\n}\n
    coin_change_ii.c
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDP(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int **dp = malloc((n + 1) * sizeof(int *));\n    for (int i = 0; i <= n; i++) {\n        dp[i] = calloc(amt + 1, sizeof(int));\n    }\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (int i = 0; i <= n; i++) {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[n][amt];\n    // \u91ca\u653e\u5185\u5b58\n    for (int i = 0; i <= n; i++) {\n        free(dp[i]);\n    }\n    free(dp);\n    return res;\n}\n
    coin_change_ii.kt
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212 */\nfun coinChangeIIDP(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = Array(n + 1) { IntArray(amt + 1) }\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (i in 0..n) {\n        dp[i][0] = 1\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[i][a] = dp[i - 1][a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[n][amt]\n}\n
    coin_change_ii.rb
    [class]{}-[func]{coin_change_ii_dp}\n
    coin_change_ii.zig
    // \u96f6\u94b1\u5151\u6362 II\uff1a\u52a8\u6001\u89c4\u5212\nfn coinChangeIIDP(comptime coins: []i32, comptime amt: usize) i32 {\n    comptime var n = coins.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_][amt + 1]i32{[_]i32{0} ** (amt + 1)} ** (n + 1);\n    // \u521d\u59cb\u5316\u9996\u5217\n    for (0..n + 1) |i| {\n        dp[i][0] = 1;\n    }\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..amt + 1) |a| {\n            if (coins[i - 1] > @as(i32, @intCast(a))) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[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\n                dp[i][a] = dp[i - 1][a] + dp[i][a - @as(usize, @intCast(coins[i - 1]))];\n            }\n        }\n    }\n    return dp[n][amt];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_dynamic_programming/unbounded_knapsack_problem/#3_2","title":"3. \u00a0 \u7a7a\u95f4\u4f18\u5316","text":"

    \u7a7a\u95f4\u4f18\u5316\u5904\u7406\u65b9\u5f0f\u76f8\u540c\uff0c\u5220\u9664\u786c\u5e01\u7ef4\u5ea6\u5373\u53ef\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig coin_change_ii.py
    def coin_change_ii_dp_comp(coins: list[int], amt: int) -> int:\n    \"\"\"\u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\"\"\"\n    n = len(coins)\n    # \u521d\u59cb\u5316 dp \u8868\n    dp = [0] * (amt + 1)\n    dp[0] = 1\n    # \u72b6\u6001\u8f6c\u79fb\n    for i in range(1, n + 1):\n        # \u6b63\u5e8f\u904d\u5386\n        for a in range(1, amt + 1):\n            if coins[i - 1] > a:\n                # \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            else:\n                # \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n    return dp[amt]\n
    coin_change_ii.cpp
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(vector<int> &coins, int amt) {\n    int n = coins.size();\n    // \u521d\u59cb\u5316 dp \u8868\n    vector<int> dp(amt + 1, 0);\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.java
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.cs
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint CoinChangeIIDPComp(int[] coins, int amt) {\n    int n = coins.Length;\n    // \u521d\u59cb\u5316 dp \u8868\n    int[] dp = new int[amt + 1];\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.go
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeIIDPComp(coins []int, amt int) int {\n    n := len(coins)\n    // \u521d\u59cb\u5316 dp \u8868\n    dp := make([]int, amt+1)\n    dp[0] = 1\n    // \u72b6\u6001\u8f6c\u79fb\n    for i := 1; i <= n; i++ {\n        // \u5012\u5e8f\u904d\u5386\n        for a := 1; a <= amt; a++ {\n            if coins[i-1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a-coins[i-1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n
    coin_change_ii.swift
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunc coinChangeIIDPComp(coins: [Int], amt: Int) -> Int {\n    let n = coins.count\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = Array(repeating: 0, count: amt + 1)\n    dp[0] = 1\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1 ... n {\n        for a in 1 ... amt {\n            if coins[i - 1] > a {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n
    coin_change_ii.js
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeIIDPComp(coins, amt) {\n    const n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: amt + 1 }, () => 0);\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.ts
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u72b6\u6001\u538b\u7f29\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfunction coinChangeIIDPComp(coins: Array<number>, amt: number): number {\n    const n = coins.length;\n    // \u521d\u59cb\u5316 dp \u8868\n    const dp = Array.from({ length: amt + 1 }, () => 0);\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (let i = 1; i <= n; i++) {\n        for (let a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    coin_change_ii.dart
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(List<int> coins, int amt) {\n  int n = coins.length;\n  // \u521d\u59cb\u5316 dp \u8868\n  List<int> dp = List.filled(amt + 1, 0);\n  dp[0] = 1;\n  // \u72b6\u6001\u8f6c\u79fb\n  for (int i = 1; i <= n; i++) {\n    for (int a = 1; a <= amt; a++) {\n      if (coins[i - 1] > a) {\n        // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n        dp[a] = dp[a];\n      } else {\n        // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n        dp[a] = dp[a] + dp[a - coins[i - 1]];\n      }\n    }\n  }\n  return dp[amt];\n}\n
    coin_change_ii.rs
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfn coin_change_ii_dp_comp(coins: &[i32], amt: usize) -> i32 {\n    let n = coins.len();\n    // \u521d\u59cb\u5316 dp \u8868\n    let mut dp = vec![0; amt + 1];\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for i in 1..=n {\n        for a in 1..=amt {\n            if coins[i - 1] > a as i32 {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1] as usize];\n            }\n        }\n    }\n    dp[amt]\n}\n
    coin_change_ii.c
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nint coinChangeIIDPComp(int coins[], int amt, int coinsSize) {\n    int n = coinsSize;\n    // \u521d\u59cb\u5316 dp \u8868\n    int *dp = calloc(amt + 1, sizeof(int));\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (int i = 1; i <= n; i++) {\n        for (int a = 1; a <= amt; a++) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]];\n            }\n        }\n    }\n    int res = dp[amt];\n    // \u91ca\u653e\u5185\u5b58\n    free(dp);\n    return res;\n}\n
    coin_change_ii.kt
    /* \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212 */\nfun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {\n    val n = coins.size\n    // \u521d\u59cb\u5316 dp \u8868\n    val dp = IntArray(amt + 1)\n    dp[0] = 1\n    // \u72b6\u6001\u8f6c\u79fb\n    for (i in 1..n) {\n        for (a in 1..amt) {\n            if (coins[i - 1] > a) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a]\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u4e4b\u548c\n                dp[a] = dp[a] + dp[a - coins[i - 1]]\n            }\n        }\n    }\n    return dp[amt]\n}\n
    coin_change_ii.rb
    [class]{}-[func]{coin_change_ii_dp_comp}\n
    coin_change_ii.zig
    // \u96f6\u94b1\u5151\u6362 II\uff1a\u7a7a\u95f4\u4f18\u5316\u540e\u7684\u52a8\u6001\u89c4\u5212\nfn coinChangeIIDPComp(comptime coins: []i32, comptime amt: usize) i32 {\n    comptime var n = coins.len;\n    // \u521d\u59cb\u5316 dp \u8868\n    var dp = [_]i32{0} ** (amt + 1);\n    dp[0] = 1;\n    // \u72b6\u6001\u8f6c\u79fb\n    for (1..n + 1) |i| {\n        for (1..amt + 1) |a| {\n            if (coins[i - 1] > @as(i32, @intCast(a))) {\n                // \u82e5\u8d85\u8fc7\u76ee\u6807\u91d1\u989d\uff0c\u5219\u4e0d\u9009\u786c\u5e01 i\n                dp[a] = dp[a];\n            } else {\n                // \u4e0d\u9009\u548c\u9009\u786c\u5e01 i \u8fd9\u4e24\u79cd\u65b9\u6848\u7684\u8f83\u5c0f\u503c\n                dp[a] = dp[a] + dp[a - @as(usize, @intCast(coins[i - 1]))];\n            }\n        }\n    }\n    return dp[amt];\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_graph/","title":"\u7b2c 9 \u7ae0 \u00a0 \u56fe","text":"

    Abstract

    \u5728\u751f\u547d\u65c5\u9014\u4e2d\uff0c\u6211\u4eec\u5c31\u50cf\u662f\u4e00\u4e2a\u4e2a\u8282\u70b9\uff0c\u88ab\u65e0\u6570\u770b\u4e0d\u89c1\u7684\u8fb9\u76f8\u8fde\u3002

    \u6bcf\u4e00\u6b21\u7684\u76f8\u8bc6\u4e0e\u76f8\u79bb\uff0c\u90fd\u5728\u8fd9\u5f20\u5de8\u5927\u7684\u7f51\u7edc\u56fe\u4e2d\u7559\u4e0b\u72ec\u7279\u7684\u5370\u8bb0\u3002

    "},{"location":"chapter_graph/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 9.1 \u00a0 \u56fe
    • 9.2 \u00a0 \u56fe\u57fa\u7840\u64cd\u4f5c
    • 9.3 \u00a0 \u56fe\u7684\u904d\u5386
    • 9.4 \u00a0 \u5c0f\u7ed3
    "},{"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} \\]

    \u5982\u679c\u5c06\u9876\u70b9\u770b\u4f5c\u8282\u70b9\uff0c\u5c06\u8fb9\u770b\u4f5c\u8fde\u63a5\u5404\u4e2a\u8282\u70b9\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5c06\u56fe\u770b\u4f5c\u4e00\u79cd\u4ece\u94fe\u8868\u62d3\u5c55\u800c\u6765\u7684\u6570\u636e\u7ed3\u6784\u3002\u5982\u56fe 9-1 \u6240\u793a\uff0c\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\u56e0\u800c\u66f4\u4e3a\u590d\u6742\u3002

    \u56fe 9-1 \u00a0 \u94fe\u8868\u3001\u6811\u3001\u56fe\u4e4b\u95f4\u7684\u5173\u7cfb

    "},{"location":"chapter_graph/graph/#911","title":"9.1.1 \u00a0 \u56fe\u7684\u5e38\u89c1\u7c7b\u578b\u4e0e\u672f\u8bed","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\uff0c\u5982\u56fe 9-2 \u6240\u793a\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\u3002
    • \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\u3002

    \u56fe 9-2 \u00a0 \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\uff0c\u5982\u56fe 9-3 \u6240\u793a\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\u3002
    • \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\u3002

    \u56fe 9-3 \u00a0 \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\u5982\u56fe 9-4 \u6240\u793a\u7684\u300c\u6709\u6743\u56fe weighted graph\u300d\u3002\u4f8b\u5982\u5728\u300a\u738b\u8005\u8363\u8000\u300b\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

    \u56fe 9-4 \u00a0 \u6709\u6743\u56fe\u4e0e\u65e0\u6743\u56fe

    \u56fe\u6570\u636e\u7ed3\u6784\u5305\u542b\u4ee5\u4e0b\u5e38\u7528\u672f\u8bed\u3002

    • \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\u56fe 9-4 \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\u56fe 9-4 \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\uff1a\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/#912","title":"9.1.2 \u00a0 \u56fe\u7684\u8868\u793a","text":"

    \u56fe\u7684\u5e38\u7528\u8868\u793a\u65b9\u5f0f\u5305\u62ec\u201c\u90bb\u63a5\u77e9\u9635\u201d\u548c\u201c\u90bb\u63a5\u8868\u201d\u3002\u4ee5\u4e0b\u4f7f\u7528\u65e0\u5411\u56fe\u8fdb\u884c\u4e3e\u4f8b\u3002

    "},{"location":"chapter_graph/graph/#1","title":"1. \u00a0 \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\u56fe 9-5 \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

    \u56fe 9-5 \u00a0 \u56fe\u7684\u90bb\u63a5\u77e9\u9635\u8868\u793a

    \u90bb\u63a5\u77e9\u9635\u5177\u6709\u4ee5\u4e0b\u7279\u6027\u3002

    • \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\\) \u548c \\(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\u6539\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":"2. \u00a0 \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\\) \u4e2a\u94fe\u8868\u5bf9\u5e94\u9876\u70b9 \\(i\\) \uff0c\u5176\u4e2d\u5b58\u50a8\u4e86\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\uff08\u4e0e\u8be5\u9876\u70b9\u76f8\u8fde\u7684\u9876\u70b9\uff09\u3002\u56fe 9-6 \u5c55\u793a\u4e86\u4e00\u4e2a\u4f7f\u7528\u90bb\u63a5\u8868\u5b58\u50a8\u7684\u56fe\u7684\u793a\u4f8b\u3002

    \u56fe 9-6 \u00a0 \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\u56fe 9-6 \uff0c\u90bb\u63a5\u8868\u7ed3\u6784\u4e0e\u54c8\u5e0c\u8868\u4e2d\u7684\u201c\u94fe\u5f0f\u5730\u5740\u201d\u975e\u5e38\u76f8\u4f3c\uff0c\u56e0\u6b64\u6211\u4eec\u4e5f\u53ef\u4ee5\u91c7\u7528\u7c7b\u4f3c\u7684\u65b9\u6cd5\u6765\u4f18\u5316\u6548\u7387\u3002\u6bd4\u5982\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)\\) \uff1b\u8fd8\u53ef\u4ee5\u628a\u94fe\u8868\u8f6c\u6362\u4e3a\u54c8\u5e0c\u8868\uff0c\u4ece\u800c\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u964d\u81f3 \\(O(1)\\) \u3002

    "},{"location":"chapter_graph/graph/#913","title":"9.1.3 \u00a0 \u56fe\u7684\u5e38\u89c1\u5e94\u7528","text":"

    \u5982\u8868 9-1 \u6240\u793a\uff0c\u8bb8\u591a\u73b0\u5b9e\u7cfb\u7edf\u53ef\u4ee5\u7528\u56fe\u6765\u5efa\u6a21\uff0c\u76f8\u5e94\u7684\u95ee\u9898\u4e5f\u53ef\u4ee5\u7ea6\u5316\u4e3a\u56fe\u8ba1\u7b97\u95ee\u9898\u3002

    \u8868 9-1 \u00a0 \u73b0\u5b9e\u751f\u6d3b\u4e2d\u5e38\u89c1\u7684\u56fe

    \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\u7684\u57fa\u7840\u64cd\u4f5c","text":"

    \u56fe\u7684\u57fa\u7840\u64cd\u4f5c\u53ef\u5206\u4e3a\u5bf9\u201c\u8fb9\u201d\u7684\u64cd\u4f5c\u548c\u5bf9\u201c\u9876\u70b9\u201d\u7684\u64cd\u4f5c\u3002\u5728\u201c\u90bb\u63a5\u77e9\u9635\u201d\u548c\u201c\u90bb\u63a5\u8868\u201d\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\u5404\u79cd\u64cd\u4f5c\u7684\u5b9e\u73b0\u65b9\u5f0f\u5982\u56fe 9-7 \u6240\u793a\u3002

    • \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

    \u56fe 9-7 \u00a0 \u90bb\u63a5\u77e9\u9635\u7684\u521d\u59cb\u5316\u3001\u589e\u5220\u8fb9\u3001\u589e\u5220\u9876\u70b9

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u8868\u793a\u56fe\u7684\u5b9e\u73b0\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_adjacency_matrix.py
    class GraphAdjMat:\n    \"\"\"\u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\n\n    def __init__(self, vertices: list[int], edges: list[list[int]]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\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\n        self.vertices: list[int] = []\n        # \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n        self.adj_mat: list[list[int]] = []\n        # \u6dfb\u52a0\u9876\u70b9\n        for val in vertices:\n            self.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\n        for e in edges:\n            self.add_edge(e[0], e[1])\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\n        return len(self.vertices)\n\n    def add_vertex(self, val: int):\n        \"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\n        n = self.size()\n        # \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        self.vertices.append(val)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        new_row = [0] * n\n        self.adj_mat.append(new_row)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for row in self.adj_mat:\n            row.append(0)\n\n    def remove_vertex(self, index: int):\n        \"\"\"\u5220\u9664\u9876\u70b9\"\"\"\n        if index >= self.size():\n            raise IndexError()\n        # \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        self.vertices.pop(index)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        self.adj_mat.pop(index)\n        # \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for row in self.adj_mat:\n            row.pop(index)\n\n    def add_edge(self, i: int, j: int):\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\n        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\n            raise IndexError()\n        # \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1\n        self.adj_mat[j][i] = 1\n\n    def remove_edge(self, i: int, j: int):\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\n        if i < 0 or j < 0 or i >= self.size() or j >= self.size() or i == j:\n            raise IndexError()\n        self.adj_mat[i][j] = 0\n        self.adj_mat[j][i] = 0\n\n    def print(self):\n        \"\"\"\u6253\u5370\u90bb\u63a5\u77e9\u9635\"\"\"\n        print(\"\u9876\u70b9\u5217\u8868 =\", self.vertices)\n        print(\"\u90bb\u63a5\u77e9\u9635 =\")\n        print_matrix(self.adj_mat)\n
    graph_adjacency_matrix.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    vector<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\n    vector<vector<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    GraphAdjMat(const vector<int> &vertices, const vector<vector<int>> &edges) {\n        // \u6dfb\u52a0\u9876\u70b9\n        for (int val : vertices) {\n            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\n        for (const vector<int> &edge : edges) {\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int size() const {\n        return vertices.size();\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    void addVertex(int val) {\n        int n = size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.push_back(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        adjMat.emplace_back(vector<int>(n, 0));\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (vector<int> &row : adjMat) {\n            row.push_back(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    void removeVertex(int index) {\n        if (index >= size()) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.erase(vertices.begin() + index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.erase(adjMat.begin() + index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (vector<int> &row : adjMat) {\n            row.erase(row.begin() + index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    void addEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    void removeEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n            throw out_of_range(\"\u9876\u70b9\u4e0d\u5b58\u5728\");\n        }\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    void print() {\n        cout << \"\u9876\u70b9\u5217\u8868 = \";\n        printVector(vertices);\n        cout << \"\u90bb\u63a5\u77e9\u9635 =\" << endl;\n        printVectorMatrix(adjMat);\n    }\n};\n
    graph_adjacency_matrix.java
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    List<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\n    List<List<Integer>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = new ArrayList<>();\n        this.adjMat = new ArrayList<>();\n        // \u6dfb\u52a0\u9876\u70b9\n        for (int val : vertices) {\n            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\n        for (int[] e : edges) {\n            addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public int size() {\n        return vertices.size();\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void addVertex(int val) {\n        int n = size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.add(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        List<Integer> newRow = new ArrayList<>(n);\n        for (int j = 0; j < n; j++) {\n            newRow.add(0);\n        }\n        adjMat.add(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (List<Integer> row : adjMat) {\n            row.add(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void removeVertex(int index) {\n        if (index >= size())\n            throw new IndexOutOfBoundsException();\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (List<Integer> row : adjMat) {\n            row.remove(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void addEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat.get(i).set(j, 1);\n        adjMat.get(j).set(i, 1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void removeEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j)\n            throw new IndexOutOfBoundsException();\n        adjMat.get(i).set(j, 0);\n        adjMat.get(j).set(i, 0);\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    public void print() {\n        System.out.print(\"\u9876\u70b9\u5217\u8868 = \");\n        System.out.println(vertices);\n        System.out.println(\"\u90bb\u63a5\u77e9\u9635 =\");\n        PrintUtil.printMatrix(adjMat);\n    }\n}\n
    graph_adjacency_matrix.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    List<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\n    List<List<int>> adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    public GraphAdjMat(int[] vertices, int[][] edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        foreach (int val in vertices) {\n            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\n        foreach (int[] e in edges) {\n            AddEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int Size() {\n        return vertices.Count;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void AddVertex(int val) {\n        int n = Size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.Add(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        List<int> newRow = new(n);\n        for (int j = 0; j < n; j++) {\n            newRow.Add(0);\n        }\n        adjMat.Add(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        foreach (List<int> row in adjMat) {\n            row.Add(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void RemoveVertex(int index) {\n        if (index >= Size())\n            throw new IndexOutOfRangeException();\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.RemoveAt(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.RemoveAt(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        foreach (List<int> row in adjMat) {\n            row.RemoveAt(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void AddEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    public void RemoveEdge(int i, int j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)\n            throw new IndexOutOfRangeException();\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    public void Print() {\n        Console.Write(\"\u9876\u70b9\u5217\u8868 = \");\n        PrintUtil.PrintList(vertices);\n        Console.WriteLine(\"\u90bb\u63a5\u77e9\u9635 =\");\n        PrintUtil.PrintMatrix(adjMat);\n    }\n}\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\n    vertices []int\n    // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n    adjMat [][]int\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {\n    // \u6dfb\u52a0\u9876\u70b9\n    n := len(vertices)\n    adjMat := make([][]int, n)\n    for i := range adjMat {\n        adjMat[i] = make([]int, n)\n    }\n    // \u521d\u59cb\u5316\u56fe\n    g := &graphAdjMat{\n        vertices: vertices,\n        adjMat:   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\n    for i := range edges {\n        g.addEdge(edges[i][0], edges[i][1])\n    }\n    return g\n}\n\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjMat) size() int {\n    return len(g.vertices)\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjMat) addVertex(val int) {\n    n := g.size()\n    // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n    g.vertices = append(g.vertices, val)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n    newRow := make([]int, n)\n    g.adjMat = append(g.adjMat, newRow)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i], 0)\n    }\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjMat) removeVertex(index int) {\n    if index >= g.size() {\n        return\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for i := range g.adjMat {\n        g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)\n    }\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\n    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n    g.adjMat[i][j] = 1\n    g.adjMat[j][i] = 1\n}\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\n    if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {\n        fmt.Errorf(\"%s\", \"Index Out Of Bounds Exception\")\n    }\n    g.adjMat[i][j] = 0\n    g.adjMat[j][i] = 0\n}\n\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nfunc (g *graphAdjMat) print() {\n    fmt.Printf(\"\\t\u9876\u70b9\u5217\u8868 = %v\\n\", g.vertices)\n    fmt.Printf(\"\\t\u90bb\u63a5\u77e9\u9635 = \\n\")\n    for i := range g.adjMat {\n        fmt.Printf(\"\\t\\t\\t%v\\n\", g.adjMat[i])\n    }\n}\n
    graph_adjacency_matrix.swift
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    private 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\n    private var adjMat: [[Int]] // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(vertices: [Int], edges: [[Int]]) {\n        self.vertices = []\n        adjMat = []\n        // \u6dfb\u52a0\u9876\u70b9\n        for val in vertices {\n            addVertex(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\n        for e in edges {\n            addEdge(i: e[0], j: e[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    func size() -> Int {\n        vertices.count\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    func addVertex(val: Int) {\n        let n = size()\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.append(val)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        let newRow = Array(repeating: 0, count: n)\n        adjMat.append(newRow)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for i in adjMat.indices {\n            adjMat[i].append(0)\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    func removeVertex(index: Int) {\n        if index >= size() {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.remove(at: index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.remove(at: index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for i in adjMat.indices {\n            adjMat[i].remove(at: index)\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    func addEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1\n        adjMat[j][i] = 1\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    func removeEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i < 0 || j < 0 || i >= size() || j >= size() || i == j {\n            fatalError(\"\u8d8a\u754c\")\n        }\n        adjMat[i][j] = 0\n        adjMat[j][i] = 0\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    func print() {\n        Swift.print(\"\u9876\u70b9\u5217\u8868 = \", terminator: \"\")\n        Swift.print(vertices)\n        Swift.print(\"\u90bb\u63a5\u77e9\u9635 =\")\n        PrintUtil.printMatrix(matrix: adjMat)\n    }\n}\n
    graph_adjacency_matrix.js
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n    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\n    adjMat; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    constructor(vertices, edges) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        for (const val of vertices) {\n            this.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\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size() {\n        return this.vertices.length;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(val) {\n        const n = this.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        this.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        const newRow = [];\n        for (let j = 0; j < n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(index) {\n        if (index >= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        this.vertices.splice(index, 1);\n\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        this.adjMat.splice(index, 1);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    addEdge(i, j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    removeEdge(i, j) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    print() {\n        console.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\n        console.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 {\n    vertices: 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\n    adjMat: number[][]; // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    constructor(vertices: number[], edges: number[][]) {\n        this.vertices = [];\n        this.adjMat = [];\n        // \u6dfb\u52a0\u9876\u70b9\n        for (const val of vertices) {\n            this.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\n        for (const e of edges) {\n            this.addEdge(e[0], e[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size(): number {\n        return this.vertices.length;\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(val: number): void {\n        const n: number = this.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        this.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        const newRow: number[] = [];\n        for (let j: number = 0; j < n; j++) {\n            newRow.push(0);\n        }\n        this.adjMat.push(newRow);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (const row of this.adjMat) {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(index: number): void {\n        if (index >= this.size()) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        this.vertices.splice(index, 1);\n\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        this.adjMat.splice(index, 1);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (const row of this.adjMat) {\n            row.splice(index, 1);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    addEdge(i: number, j: number): void {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) === (j, i)\n        this.adjMat[i][j] = 1;\n        this.adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    removeEdge(i: number, j: number): void {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {\n            throw new RangeError('Index Out Of Bounds Exception');\n        }\n        this.adjMat[i][j] = 0;\n        this.adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    print(): void {\n        console.log('\u9876\u70b9\u5217\u8868 = ', this.vertices);\n        console.log('\u90bb\u63a5\u77e9\u9635 =', this.adjMat);\n    }\n}\n
    graph_adjacency_matrix.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat {\n  List<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\n  List<List<int>> adjMat = []; //\u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  GraphAdjMat(List<int> vertices, List<List<int>> edges) {\n    this.vertices = [];\n    this.adjMat = [];\n    // \u6dfb\u52a0\u9876\u70b9\n    for (int val in vertices) {\n      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\n    for (List<int> e in edges) {\n      addEdge(e[0], e[1]);\n    }\n  }\n\n  /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n  int size() {\n    return vertices.length;\n  }\n\n  /* \u6dfb\u52a0\u9876\u70b9 */\n  void addVertex(int val) {\n    int n = size();\n    // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n    vertices.add(val);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n    List<int> newRow = List.filled(n, 0, growable: true);\n    adjMat.add(newRow);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n    for (List<int> row in adjMat) {\n      row.add(0);\n    }\n  }\n\n  /* \u5220\u9664\u9876\u70b9 */\n  void removeVertex(int index) {\n    if (index >= size()) {\n      throw IndexError;\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    vertices.removeAt(index);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    adjMat.removeAt(index);\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for (List<int> row in adjMat) {\n      row.removeAt(index);\n    }\n  }\n\n  /* \u6dfb\u52a0\u8fb9 */\n  // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n  void addEdge(int i, int j) {\n    // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n      throw IndexError;\n    }\n    // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n    adjMat[i][j] = 1;\n    adjMat[j][i] = 1;\n  }\n\n  /* \u5220\u9664\u8fb9 */\n  // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n  void removeEdge(int i, int j) {\n    // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {\n      throw IndexError;\n    }\n    adjMat[i][j] = 0;\n    adjMat[j][i] = 0;\n  }\n\n  /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n  void printAdjMat() {\n    print(\"\u9876\u70b9\u5217\u8868 = $vertices\");\n    print(\"\u90bb\u63a5\u77e9\u9635 = \");\n    printMatrix(adjMat);\n  }\n}\n
    graph_adjacency_matrix.rs
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\u578b */\npub struct GraphAdjMat {\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\n    pub vertices: Vec<i32>,\n    // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n    pub adj_mat: Vec<Vec<i32>>,\n}\n\nimpl GraphAdjMat {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(vertices: Vec<i32>, edges: Vec<[usize; 2]>) -> Self {\n        let mut graph = GraphAdjMat {\n            vertices: vec![],\n            adj_mat: vec![],\n        };\n        // \u6dfb\u52a0\u9876\u70b9\n        for val in vertices {\n            graph.add_vertex(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\n        for edge in edges {\n            graph.add_edge(edge[0], edge[1])\n        }\n\n        graph\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    pub fn size(&self) -> usize {\n        self.vertices.len()\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    pub fn add_vertex(&mut self, val: i32) {\n        let n = self.size();\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        self.vertices.push(val);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        self.adj_mat.push(vec![0; n]);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for row in &mut self.adj_mat {\n            row.push(0);\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    pub fn remove_vertex(&mut self, index: usize) {\n        if index >= self.size() {\n            panic!(\"index error\")\n        }\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        self.vertices.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        self.adj_mat.remove(index);\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for row in &mut self.adj_mat {\n            row.remove(index);\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    pub fn add_edge(&mut self, i: usize, j: usize) {\n        // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i >= self.size() || j >= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        self.adj_mat[i][j] = 1;\n        self.adj_mat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    pub fn remove_edge(&mut self, i: usize, j: usize) {\n        // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if i >= self.size() || j >= self.size() || i == j {\n            panic!(\"index error\")\n        }\n        self.adj_mat[i][j] = 0;\n        self.adj_mat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    pub fn print(&self) {\n        println!(\"\u9876\u70b9\u5217\u8868 = {:?}\", self.vertices);\n        println!(\"\u90bb\u63a5\u77e9\u9635 =\");\n        println!(\"[\");\n        for row in &self.adj_mat {\n            println!(\"  {:?},\", row);\n        }\n        println!(\"]\")\n    }\n}\n
    graph_adjacency_matrix.c
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7ed3\u6784\u4f53 */\ntypedef struct {\n    int vertices[MAX_SIZE];\n    int adjMat[MAX_SIZE][MAX_SIZE];\n    int size;\n} GraphAdjMat;\n\n/* \u6784\u9020\u51fd\u6570 */\nGraphAdjMat *newGraphAdjMat() {\n    GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));\n    graph->size = 0;\n    for (int i = 0; i < MAX_SIZE; i++) {\n        for (int j = 0; j < MAX_SIZE; j++) {\n            graph->adjMat[i][j] = 0;\n        }\n    }\n    return graph;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delGraphAdjMat(GraphAdjMat *graph) {\n    free(graph);\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(GraphAdjMat *graph, int val) {\n    if (graph->size == MAX_SIZE) {\n        fprintf(stderr, \"\u56fe\u7684\u9876\u70b9\u6570\u91cf\u5df2\u8fbe\u6700\u5927\u503c\\n\");\n        return;\n    }\n    // \u6dfb\u52a0\u7b2c n \u4e2a\u9876\u70b9\uff0c\u5e76\u5c06\u7b2c n \u884c\u548c\u5217\u7f6e\u96f6\n    int n = graph->size;\n    graph->vertices[n] = val;\n    for (int i = 0; i <= n; i++) {\n        graph->adjMat[n][i] = graph->adjMat[i][n] = 0;\n    }\n    graph->size++;\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(GraphAdjMat *graph, int index) {\n    if (index < 0 || index >= graph->size) {\n        fprintf(stderr, \"\u9876\u70b9\u7d22\u5f15\u8d8a\u754c\\n\");\n        return;\n    }\n    // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n    for (int i = index; i < graph->size - 1; i++) {\n        graph->vertices[i] = graph->vertices[i + 1];\n    }\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n    for (int i = index; i < graph->size - 1; i++) {\n        for (int j = 0; j < graph->size; j++) {\n            graph->adjMat[i][j] = graph->adjMat[i + 1][j];\n        }\n    }\n    // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n    for (int i = 0; i < graph->size; i++) {\n        for (int j = index; j < graph->size - 1; j++) {\n            graph->adjMat[i][j] = graph->adjMat[i][j + 1];\n        }\n    }\n    graph->size--;\n}\n\n/* \u6dfb\u52a0\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid addEdge(GraphAdjMat *graph, int i, int j) {\n    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {\n        fprintf(stderr, \"\u8fb9\u7d22\u5f15\u8d8a\u754c\u6216\u76f8\u7b49\\n\");\n        return;\n    }\n    graph->adjMat[i][j] = 1;\n    graph->adjMat[j][i] = 1;\n}\n\n/* \u5220\u9664\u8fb9 */\n// \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\nvoid removeEdge(GraphAdjMat *graph, int i, int j) {\n    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {\n        fprintf(stderr, \"\u8fb9\u7d22\u5f15\u8d8a\u754c\u6216\u76f8\u7b49\\n\");\n        return;\n    }\n    graph->adjMat[i][j] = 0;\n    graph->adjMat[j][i] = 0;\n}\n\n/* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\nvoid printGraphAdjMat(GraphAdjMat *graph) {\n    printf(\"\u9876\u70b9\u5217\u8868 = \");\n    printArray(graph->vertices, graph->size);\n    printf(\"\u90bb\u63a5\u77e9\u9635 =\\n\");\n    for (int i = 0; i < graph->size; i++) {\n        printArray(graph->adjMat[i], graph->size);\n    }\n}\n
    graph_adjacency_matrix.kt
    /* \u57fa\u4e8e\u90bb\u63a5\u77e9\u9635\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjMat(vertices: IntArray, edges: Array<IntArray>) {\n    val vertices: MutableList<Int> = ArrayList() // \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\n    val adjMat: MutableList<MutableList<Int>> = ArrayList() // \u90bb\u63a5\u77e9\u9635\uff0c\u884c\u5217\u7d22\u5f15\u5bf9\u5e94\u201c\u9876\u70b9\u7d22\u5f15\u201d\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        // \u6dfb\u52a0\u9876\u70b9\n        for (vertex in vertices) {\n            addVertex(vertex)\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\n        for (edge in edges) {\n            addEdge(edge[0], edge[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    fun size(): Int {\n        return vertices.size\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    fun addVertex(value: Int) {\n        val n = size()\n        // \u5411\u9876\u70b9\u5217\u8868\u4e2d\u6dfb\u52a0\u65b0\u9876\u70b9\u7684\u503c\n        vertices.add(value)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u884c\n        val newRow: MutableList<Int> = mutableListOf()\n        for (j in 0..<n) {\n            newRow.add(0)\n        }\n        adjMat.add(newRow)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u6dfb\u52a0\u4e00\u5217\n        for (row in adjMat) {\n            row.add(0)\n        }\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    fun removeVertex(index: Int) {\n        if (index >= size()) throw IndexOutOfBoundsException()\n        // \u5728\u9876\u70b9\u5217\u8868\u4e2d\u79fb\u9664\u7d22\u5f15 index \u7684\u9876\u70b9\n        vertices.removeAt(index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u884c\n        adjMat.removeAt(index)\n        // \u5728\u90bb\u63a5\u77e9\u9635\u4e2d\u5220\u9664\u7d22\u5f15 index \u7684\u5217\n        for (row in adjMat) {\n            row.removeAt(index)\n        }\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    fun addEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) throw java.lang.IndexOutOfBoundsException()\n        // \u5728\u65e0\u5411\u56fe\u4e2d\uff0c\u90bb\u63a5\u77e9\u9635\u5173\u4e8e\u4e3b\u5bf9\u89d2\u7ebf\u5bf9\u79f0\uff0c\u5373\u6ee1\u8db3 (i, j) == (j, i)\n        adjMat[i][j] = 1;\n        adjMat[j][i] = 1;\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    // \u53c2\u6570 i, j \u5bf9\u5e94 vertices \u5143\u7d20\u7d22\u5f15\n    fun removeEdge(i: Int, j: Int) {\n        // \u7d22\u5f15\u8d8a\u754c\u4e0e\u76f8\u7b49\u5904\u7406\n        if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) throw java.lang.IndexOutOfBoundsException()\n        adjMat[i][j] = 0;\n        adjMat[j][i] = 0;\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u77e9\u9635 */\n    fun print() {\n        print(\"\u9876\u70b9\u5217\u8868 = \")\n        println(vertices);\n        println(\"\u90bb\u63a5\u77e9\u9635 =\");\n        printMatrix(adjMat)\n    }\n}\n
    graph_adjacency_matrix.rb
    [class]{GraphAdjMat}-[func]{}\n
    graph_adjacency_matrix.zig
    [class]{GraphAdjMat}-[func]{}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u53ef\u6839\u636e\u56fe 9-8 \u6240\u793a\u7684\u65b9\u6cd5\u5b9e\u73b0\u5404\u79cd\u64cd\u4f5c\u3002

    • \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

    \u56fe 9-8 \u00a0 \u90bb\u63a5\u8868\u7684\u521d\u59cb\u5316\u3001\u589e\u5220\u8fb9\u3001\u589e\u5220\u9876\u70b9

    \u4ee5\u4e0b\u662f\u90bb\u63a5\u8868\u7684\u4ee3\u7801\u5b9e\u73b0\u3002\u5bf9\u6bd4\u56fe 9-8 \uff0c\u5b9e\u9645\u4ee3\u7801\u6709\u4ee5\u4e0b\u4e0d\u540c\u3002

    • \u4e3a\u4e86\u65b9\u4fbf\u6dfb\u52a0\u4e0e\u5220\u9664\u9876\u70b9\uff0c\u4ee5\u53ca\u7b80\u5316\u4ee3\u7801\uff0c\u6211\u4eec\u4f7f\u7528\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\u6765\u4ee3\u66ff\u94fe\u8868\u3002
    • \u4f7f\u7528\u54c8\u5e0c\u8868\u6765\u5b58\u50a8\u90bb\u63a5\u8868\uff0ckey \u4e3a\u9876\u70b9\u5b9e\u4f8b\uff0cvalue \u4e3a\u8be5\u9876\u70b9\u7684\u90bb\u63a5\u9876\u70b9\u5217\u8868\uff08\u94fe\u8868\uff09\u3002

    \u53e6\u5916\uff0c\u6211\u4eec\u5728\u90bb\u63a5\u8868\u4e2d\u4f7f\u7528 Vertex \u7c7b\u6765\u8868\u793a\u9876\u70b9\uff0c\u8fd9\u6837\u505a\u7684\u539f\u56e0\u662f\uff1a\u5982\u679c\u4e0e\u90bb\u63a5\u77e9\u9635\u4e00\u6837\uff0c\u7528\u5217\u8868\u7d22\u5f15\u6765\u533a\u5206\u4e0d\u540c\u9876\u70b9\uff0c\u90a3\u4e48\u5047\u8bbe\u8981\u5220\u9664\u7d22\u5f15\u4e3a \\(i\\) \u7684\u9876\u70b9\uff0c\u5219\u9700\u904d\u5386\u6574\u4e2a\u90bb\u63a5\u8868\uff0c\u5c06\u6240\u6709\u5927\u4e8e \\(i\\) \u7684\u7d22\u5f15\u5168\u90e8\u51cf \\(1\\) \uff0c\u6548\u7387\u5f88\u4f4e\u3002\u800c\u5982\u679c\u6bcf\u4e2a\u9876\u70b9\u90fd\u662f\u552f\u4e00\u7684 Vertex \u5b9e\u4f8b\uff0c\u5220\u9664\u67d0\u4e00\u9876\u70b9\u4e4b\u540e\u5c31\u65e0\u987b\u6539\u52a8\u5176\u4ed6\u9876\u70b9\u4e86\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_adjacency_list.py
    class GraphAdjList:\n    \"\"\"\u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\"\"\"\n\n    def __init__(self, edges: list[list[Vertex]]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        # \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        self.adj_list = dict[Vertex, list[Vertex]]()\n        # \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges:\n            self.add_vertex(edge[0])\n            self.add_vertex(edge[1])\n            self.add_edge(edge[0], edge[1])\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u9876\u70b9\u6570\u91cf\"\"\"\n        return len(self.adj_list)\n\n    def add_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"\u6dfb\u52a0\u8fb9\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # \u6dfb\u52a0\u8fb9 vet1 - vet2\n        self.adj_list[vet1].append(vet2)\n        self.adj_list[vet2].append(vet1)\n\n    def remove_edge(self, vet1: Vertex, vet2: Vertex):\n        \"\"\"\u5220\u9664\u8fb9\"\"\"\n        if vet1 not in self.adj_list or vet2 not in self.adj_list or vet1 == vet2:\n            raise ValueError()\n        # \u5220\u9664\u8fb9 vet1 - vet2\n        self.adj_list[vet1].remove(vet2)\n        self.adj_list[vet2].remove(vet1)\n\n    def add_vertex(self, vet: Vertex):\n        \"\"\"\u6dfb\u52a0\u9876\u70b9\"\"\"\n        if vet in self.adj_list:\n            return\n        # \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        self.adj_list[vet] = []\n\n    def remove_vertex(self, vet: Vertex):\n        \"\"\"\u5220\u9664\u9876\u70b9\"\"\"\n        if vet not in self.adj_list:\n            raise ValueError()\n        # \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        self.adj_list.pop(vet)\n        # \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for vertex in self.adj_list:\n            if vet in self.adj_list[vertex]:\n                self.adj_list[vertex].remove(vet)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u90bb\u63a5\u8868\"\"\"\n        print(\"\u90bb\u63a5\u8868 =\")\n        for vertex in self.adj_list:\n            tmp = [v.val for v in self.adj_list[vertex]]\n            print(f\"{vertex.val}: {tmp},\")\n
    graph_adjacency_list.cpp
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n  public:\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    unordered_map<Vertex *, vector<Vertex *>> adjList;\n\n    /* \u5728 vector \u4e2d\u5220\u9664\u6307\u5b9a\u8282\u70b9 */\n    void remove(vector<Vertex *> &vec, Vertex *vet) {\n        for (int i = 0; i < vec.size(); i++) {\n            if (vec[i] == vet) {\n                vec.erase(vec.begin() + i);\n                break;\n            }\n        }\n    }\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    GraphAdjList(const vector<vector<Vertex *>> &edges) {\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const vector<Vertex *> &edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int size() {\n        return adjList.size();\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    void addEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1].push_back(vet2);\n        adjList[vet2].push_back(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    void removeEdge(Vertex *vet1, Vertex *vet2) {\n        if (!adjList.count(vet1) || !adjList.count(vet2) || vet1 == vet2)\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        remove(adjList[vet1], vet2);\n        remove(adjList[vet2], vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    void addVertex(Vertex *vet) {\n        if (adjList.count(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = vector<Vertex *>();\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    void removeVertex(Vertex *vet) {\n        if (!adjList.count(vet))\n            throw invalid_argument(\"\u4e0d\u5b58\u5728\u9876\u70b9\");\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.erase(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (auto &adj : adjList) {\n            remove(adj.second, vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    void print() {\n        cout << \"\u90bb\u63a5\u8868 =\" << endl;\n        for (auto &adj : adjList) {\n            const auto &key = adj.first;\n            const auto &vec = adj.second;\n            cout << key->val << \": \";\n            printVector(vetsToVals(vec));\n        }\n    }\n};\n
    graph_adjacency_list.java
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    Map<Vertex, List<Vertex>> adjList;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public GraphAdjList(Vertex[][] edges) {\n        this.adjList = new HashMap<>();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (Vertex[] edge : edges) {\n            addVertex(edge[0]);\n            addVertex(edge[1]);\n            addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public int size() {\n        return adjList.size();\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public void addEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList.get(vet1).add(vet2);\n        adjList.get(vet2).add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public void removeEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw new IllegalArgumentException();\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList.get(vet1).remove(vet2);\n        adjList.get(vet2).remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void addVertex(Vertex vet) {\n        if (adjList.containsKey(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList.put(vet, new ArrayList<>());\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void removeVertex(Vertex vet) {\n        if (!adjList.containsKey(vet))\n            throw new IllegalArgumentException();\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (List<Vertex> list : adjList.values()) {\n            list.remove(vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public void print() {\n        System.out.println(\"\u90bb\u63a5\u8868 =\");\n        for (Map.Entry<Vertex, List<Vertex>> pair : adjList.entrySet()) {\n            List<Integer> tmp = new ArrayList<>();\n            for (Vertex vertex : pair.getValue())\n                tmp.add(vertex.val);\n            System.out.println(pair.getKey().val + \": \" + tmp + \",\");\n        }\n    }\n}\n
    graph_adjacency_list.cs
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    public Dictionary<Vertex, List<Vertex>> adjList;\n\n    /* \u6784\u9020\u51fd\u6570 */\n    public GraphAdjList(Vertex[][] edges) {\n        adjList = [];\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        foreach (Vertex[] edge in edges) {\n            AddVertex(edge[0]);\n            AddVertex(edge[1]);\n            AddEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    int Size() {\n        return adjList.Count;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public void AddEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1].Add(vet2);\n        adjList[vet2].Add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public void RemoveEdge(Vertex vet1, Vertex vet2) {\n        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)\n            throw new InvalidOperationException();\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1].Remove(vet2);\n        adjList[vet2].Remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public void AddVertex(Vertex vet) {\n        if (adjList.ContainsKey(vet))\n            return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList.Add(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public void RemoveVertex(Vertex vet) {\n        if (!adjList.ContainsKey(vet))\n            throw new InvalidOperationException();\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.Remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        foreach (List<Vertex> list in adjList.Values) {\n            list.Remove(vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public void Print() {\n        Console.WriteLine(\"\u90bb\u63a5\u8868 =\");\n        foreach (KeyValuePair<Vertex, List<Vertex>> pair in adjList) {\n            List<int> tmp = [];\n            foreach (Vertex vertex in pair.Value)\n                tmp.Add(vertex.val);\n            Console.WriteLine(pair.Key.val + \": [\" + string.Join(\", \", tmp) + \"],\");\n        }\n    }\n}\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList map[Vertex][]Vertex\n}\n\n/* \u6784\u9020\u51fd\u6570 */\nfunc newGraphAdjList(edges [][]Vertex) *graphAdjList {\n    g := &graphAdjList{\n        adjList: make(map[Vertex][]Vertex),\n    }\n    // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n    for _, edge := range edges {\n        g.addVertex(edge[0])\n        g.addVertex(edge[1])\n        g.addEdge(edge[0], edge[1])\n    }\n    return g\n}\n\n/* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\nfunc (g *graphAdjList) size() int {\n    return len(g.adjList)\n}\n\n/* \u6dfb\u52a0\u8fb9 */\nfunc (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2, \u6dfb\u52a0\u533f\u540d struct{},\n    g.adjList[vet1] = append(g.adjList[vet1], vet2)\n    g.adjList[vet2] = append(g.adjList[vet2], vet1)\n}\n\n/* \u5220\u9664\u8fb9 */\nfunc (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {\n    _, ok1 := g.adjList[vet1]\n    _, ok2 := g.adjList[vet2]\n    if !ok1 || !ok2 || vet1 == vet2 {\n        panic(\"error\")\n    }\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)\n    g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nfunc (g *graphAdjList) addVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if ok {\n        return\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    g.adjList[vet] = make([]Vertex, 0)\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nfunc (g *graphAdjList) removeVertex(vet Vertex) {\n    _, ok := g.adjList[vet]\n    if !ok {\n        panic(\"error\")\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    delete(g.adjList, vet)\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    for v, list := range g.adjList {\n        g.adjList[v] = DeleteSliceElms(list, vet)\n    }\n}\n\n/* \u6253\u5370\u90bb\u63a5\u8868 */\nfunc (g *graphAdjList) print() {\n    var builder strings.Builder\n    fmt.Printf(\"\u90bb\u63a5\u8868 = \\n\")\n    for k, v := range g.adjList {\n        builder.WriteString(\"\\t\\t\" + strconv.Itoa(k.Val) + \": \")\n        for _, vet := range v {\n            builder.WriteString(strconv.Itoa(vet.Val) + \" \")\n        }\n        fmt.Println(builder.String())\n        builder.Reset()\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    public private(set) var adjList: [Vertex: [Vertex]]\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public init(edges: [[Vertex]]) {\n        adjList = [:]\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges {\n            addVertex(vet: edge[0])\n            addVertex(vet: edge[1])\n            addEdge(vet1: edge[0], vet2: edge[1])\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    public func size() -> Int {\n        adjList.count\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    public func addEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1]?.append(vet2)\n        adjList[vet2]?.append(vet1)\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    public func removeEdge(vet1: Vertex, vet2: Vertex) {\n        if adjList[vet1] == nil || adjList[vet2] == nil || vet1 == vet2 {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1]?.removeAll { $0 == vet2 }\n        adjList[vet2]?.removeAll { $0 == vet1 }\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    public func addVertex(vet: Vertex) {\n        if adjList[vet] != nil {\n            return\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = []\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    public func removeVertex(vet: Vertex) {\n        if adjList[vet] == nil {\n            fatalError(\"\u53c2\u6570\u9519\u8bef\")\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.removeValue(forKey: vet)\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for key in adjList.keys {\n            adjList[key]?.removeAll { $0 == vet }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    public func print() {\n        Swift.print(\"\u90bb\u63a5\u8868 =\")\n        for (vertex, list) in adjList {\n            let list = list.map { $0.val }\n            Swift.print(\"\\(vertex.val): \\(list),\")\n        }\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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(edges) {\n        this.adjList = new Map();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size() {\n        return this.adjList.size;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    addEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    removeEdge(vet1, vet2) {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(vet) {\n        if (this.adjList.has(vet)) return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        this.adjList.set(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(vet) {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        this.adjList.delete(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (const set of this.adjList.values()) {\n            const index = set.indexOf(vet);\n            if (index > -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    print() {\n        console.log('\u90bb\u63a5\u8868 =');\n        for (const [key, value] of this.adjList) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.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\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    adjList: Map<Vertex, Vertex[]>;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(edges: Vertex[][]) {\n        this.adjList = new Map();\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (const edge of edges) {\n            this.addVertex(edge[0]);\n            this.addVertex(edge[1]);\n            this.addEdge(edge[0], edge[1]);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    size(): number {\n        return this.adjList.size;\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    addEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).push(vet2);\n        this.adjList.get(vet2).push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    removeEdge(vet1: Vertex, vet2: Vertex): void {\n        if (\n            !this.adjList.has(vet1) ||\n            !this.adjList.has(vet2) ||\n            vet1 === vet2\n        ) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);\n        this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    addVertex(vet: Vertex): void {\n        if (this.adjList.has(vet)) return;\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        this.adjList.set(vet, []);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    removeVertex(vet: Vertex): void {\n        if (!this.adjList.has(vet)) {\n            throw new Error('Illegal Argument Exception');\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        this.adjList.delete(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (const set of this.adjList.values()) {\n            const index: number = set.indexOf(vet);\n            if (index > -1) {\n                set.splice(index, 1);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    print(): void {\n        console.log('\u90bb\u63a5\u8868 =');\n        for (const [key, value] of this.adjList.entries()) {\n            const tmp = [];\n            for (const vertex of value) {\n                tmp.push(vertex.val);\n            }\n            console.log(key.val + ': ' + tmp.join());\n        }\n    }\n}\n
    graph_adjacency_list.dart
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList {\n  // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n  Map<Vertex, List<Vertex>> adjList = {};\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  GraphAdjList(List<List<Vertex>> edges) {\n    for (List<Vertex> edge in edges) {\n      addVertex(edge[0]);\n      addVertex(edge[1]);\n      addEdge(edge[0], edge[1]);\n    }\n  }\n\n  /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n  int size() {\n    return adjList.length;\n  }\n\n  /* \u6dfb\u52a0\u8fb9 */\n  void addEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2\n    adjList[vet1]!.add(vet2);\n    adjList[vet2]!.add(vet1);\n  }\n\n  /* \u5220\u9664\u8fb9 */\n  void removeEdge(Vertex vet1, Vertex vet2) {\n    if (!adjList.containsKey(vet1) ||\n        !adjList.containsKey(vet2) ||\n        vet1 == vet2) {\n      throw ArgumentError;\n    }\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    adjList[vet1]!.remove(vet2);\n    adjList[vet2]!.remove(vet1);\n  }\n\n  /* \u6dfb\u52a0\u9876\u70b9 */\n  void addVertex(Vertex vet) {\n    if (adjList.containsKey(vet)) return;\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    adjList[vet] = [];\n  }\n\n  /* \u5220\u9664\u9876\u70b9 */\n  void removeVertex(Vertex vet) {\n    if (!adjList.containsKey(vet)) {\n      throw ArgumentError;\n    }\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    adjList.remove(vet);\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    adjList.forEach((key, value) {\n      value.remove(vet);\n    });\n  }\n\n  /* \u6253\u5370\u90bb\u63a5\u8868 */\n  void printAdjList() {\n    print(\"\u90bb\u63a5\u8868 =\");\n    adjList.forEach((key, value) {\n      List<int> tmp = [];\n      for (Vertex vertex in value) {\n        tmp.add(vertex.val);\n      }\n      print(\"${key.val}: $tmp,\");\n    });\n  }\n}\n
    graph_adjacency_list.rs
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b\u578b */\npub struct GraphAdjList {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    pub adj_list: HashMap<Vertex, Vec<Vertex>>,\n}\n\nimpl GraphAdjList {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(edges: Vec<[Vertex; 2]>) -> Self {\n        let mut graph = GraphAdjList {\n            adj_list: HashMap::new(),\n        };\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for edge in edges {\n            graph.add_vertex(edge[0]);\n            graph.add_vertex(edge[1]);\n            graph.add_edge(edge[0], edge[1]);\n        }\n\n        graph\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    #[allow(unused)]\n    pub fn size(&self) -> usize {\n        self.adj_list.len()\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    pub fn add_edge(&mut self, vet1: Vertex, vet2: Vertex) {\n        if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2\n        {\n            panic!(\"value error\");\n        }\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        self.adj_list.get_mut(&vet1).unwrap().push(vet2);\n        self.adj_list.get_mut(&vet2).unwrap().push(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    #[allow(unused)]\n    pub fn remove_edge(&mut self, vet1: Vertex, vet2: Vertex) {\n        if !self.adj_list.contains_key(&vet1) || !self.adj_list.contains_key(&vet2) || vet1 == vet2\n        {\n            panic!(\"value error\");\n        }\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        self.adj_list\n            .get_mut(&vet1)\n            .unwrap()\n            .retain(|&vet| vet != vet2);\n        self.adj_list\n            .get_mut(&vet2)\n            .unwrap()\n            .retain(|&vet| vet != vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    pub fn add_vertex(&mut self, vet: Vertex) {\n        if self.adj_list.contains_key(&vet) {\n            return;\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        self.adj_list.insert(vet, vec![]);\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    #[allow(unused)]\n    pub fn remove_vertex(&mut self, vet: Vertex) {\n        if !self.adj_list.contains_key(&vet) {\n            panic!(\"value error\");\n        }\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        self.adj_list.remove(&vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for list in self.adj_list.values_mut() {\n            list.retain(|&v| v != vet);\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    pub fn print(&self) {\n        println!(\"\u90bb\u63a5\u8868 =\");\n        for (vertex, list) in &self.adj_list {\n            let list = list.iter().map(|vertex| vertex.val).collect::<Vec<i32>>();\n            println!(\"{}: {:?},\", vertex.val, list);\n        }\n    }\n}\n
    graph_adjacency_list.c
    /* \u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct AdjListNode {\n    Vertex *vertex;           // \u9876\u70b9\n    struct AdjListNode *next; // \u540e\u7ee7\u8282\u70b9\n} AdjListNode;\n\n/* \u67e5\u627e\u9876\u70b9\u5bf9\u5e94\u7684\u8282\u70b9 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i < graph->size; i++) {\n        if (graph->heads[i]->vertex == vet) {\n            return graph->heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* \u6dfb\u52a0\u8fb9\u8f85\u52a9\u51fd\u6570 */\nvoid addEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));\n    node->vertex = vet;\n    // \u5934\u63d2\u6cd5\n    node->next = head->next;\n    head->next = node;\n}\n\n/* \u5220\u9664\u8fb9\u8f85\u52a9\u51fd\u6570 */\nvoid removeEdgeHelper(AdjListNode *head, Vertex *vet) {\n    AdjListNode *pre = head;\n    AdjListNode *cur = head->next;\n    // \u5728\u94fe\u8868\u4e2d\u641c\u7d22 vet \u5bf9\u5e94\u8282\u70b9\n    while (cur != NULL && cur->vertex != vet) {\n        pre = cur;\n        cur = cur->next;\n    }\n    if (cur == NULL)\n        return;\n    // \u5c06 vet \u5bf9\u5e94\u8282\u70b9\u4ece\u94fe\u8868\u4e2d\u5220\u9664\n    pre->next = cur->next;\n    // \u91ca\u653e\u5185\u5b58\n    free(cur);\n}\n\n/* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\ntypedef struct {\n    AdjListNode *heads[MAX_SIZE]; // \u8282\u70b9\u6570\u7ec4\n    int size;                     // \u8282\u70b9\u6570\u91cf\n} GraphAdjList;\n\n/* \u6784\u9020\u51fd\u6570 */\nGraphAdjList *newGraphAdjList() {\n    GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));\n    if (!graph) {\n        return NULL;\n    }\n    graph->size = 0;\n    for (int i = 0; i < MAX_SIZE; i++) {\n        graph->heads[i] = NULL;\n    }\n    return graph;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delGraphAdjList(GraphAdjList *graph) {\n    for (int i = 0; i < graph->size; i++) {\n        AdjListNode *cur = graph->heads[i];\n        while (cur != NULL) {\n            AdjListNode *next = cur->next;\n            if (cur != graph->heads[i]) {\n                free(cur);\n            }\n            cur = next;\n        }\n        free(graph->heads[i]->vertex);\n        free(graph->heads[i]);\n    }\n    free(graph);\n}\n\n/* \u67e5\u627e\u9876\u70b9\u5bf9\u5e94\u7684\u8282\u70b9 */\nAdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {\n    for (int i = 0; i < graph->size; i++) {\n        if (graph->heads[i]->vertex == vet) {\n            return graph->heads[i];\n        }\n    }\n    return NULL;\n}\n\n/* \u6dfb\u52a0\u8fb9 */\nvoid addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL && head2 != NULL && head1 != head2);\n    // \u6dfb\u52a0\u8fb9 vet1 - vet2\n    addEdgeHelper(head1, vet2);\n    addEdgeHelper(head2, vet1);\n}\n\n/* \u5220\u9664\u8fb9 */\nvoid removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {\n    AdjListNode *head1 = findNode(graph, vet1);\n    AdjListNode *head2 = findNode(graph, vet2);\n    assert(head1 != NULL && head2 != NULL);\n    // \u5220\u9664\u8fb9 vet1 - vet2\n    removeEdgeHelper(head1, head2->vertex);\n    removeEdgeHelper(head2, head1->vertex);\n}\n\n/* \u6dfb\u52a0\u9876\u70b9 */\nvoid addVertex(GraphAdjList *graph, Vertex *vet) {\n    assert(graph != NULL && graph->size < MAX_SIZE);\n    AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));\n    head->vertex = vet;\n    head->next = NULL;\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n    graph->heads[graph->size++] = head;\n}\n\n/* \u5220\u9664\u9876\u70b9 */\nvoid removeVertex(GraphAdjList *graph, Vertex *vet) {\n    AdjListNode *node = findNode(graph, vet);\n    assert(node != NULL);\n    // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n    AdjListNode *cur = node, *pre = NULL;\n    while (cur) {\n        pre = cur;\n        cur = cur->next;\n        free(pre);\n    }\n    // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n    for (int i = 0; i < graph->size; i++) {\n        cur = graph->heads[i];\n        pre = NULL;\n        while (cur) {\n            pre = cur;\n            cur = cur->next;\n            if (cur && cur->vertex == vet) {\n                pre->next = cur->next;\n                free(cur);\n                break;\n            }\n        }\n    }\n    // \u5c06\u8be5\u9876\u70b9\u4e4b\u540e\u7684\u9876\u70b9\u5411\u524d\u79fb\u52a8\uff0c\u4ee5\u586b\u8865\u7a7a\u7f3a\n    int i;\n    for (i = 0; i < graph->size; i++) {\n        if (graph->heads[i] == node)\n            break;\n    }\n    for (int j = i; j < graph->size - 1; j++) {\n        graph->heads[j] = graph->heads[j + 1];\n    }\n    graph->size--;\n    free(vet);\n}\n
    graph_adjacency_list.kt
    /* \u57fa\u4e8e\u90bb\u63a5\u8868\u5b9e\u73b0\u7684\u65e0\u5411\u56fe\u7c7b */\nclass GraphAdjList(edges: Array<Array<Vertex?>>) {\n    // \u90bb\u63a5\u8868\uff0ckey\uff1a\u9876\u70b9\uff0cvalue\uff1a\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    val adjList: MutableMap<Vertex, MutableList<Vertex>> = HashMap()\n\n    /* \u6784\u9020\u51fd\u6570 */\n    init {\n        // \u6dfb\u52a0\u6240\u6709\u9876\u70b9\u548c\u8fb9\n        for (edge in edges) {\n            addVertex(edge[0]!!);\n            addVertex(edge[1]!!);\n            addEdge(edge[0]!!, edge[1]!!);\n        }\n    }\n\n    /* \u83b7\u53d6\u9876\u70b9\u6570\u91cf */\n    fun size(): Int {\n        return adjList.size\n    }\n\n    /* \u6dfb\u52a0\u8fb9 */\n    fun addEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // \u6dfb\u52a0\u8fb9 vet1 - vet2\n        adjList[vet1]?.add(vet2)\n        adjList[vet2]?.add(vet1);\n    }\n\n    /* \u5220\u9664\u8fb9 */\n    fun removeEdge(vet1: Vertex, vet2: Vertex) {\n        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)\n            throw IllegalArgumentException()\n        // \u5220\u9664\u8fb9 vet1 - vet2\n        adjList[vet1]?.remove(vet2);\n        adjList[vet2]?.remove(vet1);\n    }\n\n    /* \u6dfb\u52a0\u9876\u70b9 */\n    fun addVertex(vet: Vertex) {\n        if (adjList.containsKey(vet))\n            return\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u6dfb\u52a0\u4e00\u4e2a\u65b0\u94fe\u8868\n        adjList[vet] = mutableListOf()\n    }\n\n    /* \u5220\u9664\u9876\u70b9 */\n    fun removeVertex(vet: Vertex) {\n        if (!adjList.containsKey(vet))\n            throw IllegalArgumentException()\n        // \u5728\u90bb\u63a5\u8868\u4e2d\u5220\u9664\u9876\u70b9 vet \u5bf9\u5e94\u7684\u94fe\u8868\n        adjList.remove(vet);\n        // \u904d\u5386\u5176\u4ed6\u9876\u70b9\u7684\u94fe\u8868\uff0c\u5220\u9664\u6240\u6709\u5305\u542b vet \u7684\u8fb9\n        for (list in adjList.values) {\n            list.remove(vet)\n        }\n    }\n\n    /* \u6253\u5370\u90bb\u63a5\u8868 */\n    fun print() {\n        println(\"\u90bb\u63a5\u8868 =\")\n        for (pair in adjList.entries) {\n            val tmp = ArrayList<Int>()\n            for (vertex in pair.value) {\n                tmp.add(vertex.value)\n            }\n            println(\"${pair.key.value}: $tmp,\")\n        }\n    }\n}\n
    graph_adjacency_list.rb
    [class]{GraphAdjList}-[func]{}\n
    graph_adjacency_list.zig
    [class]{GraphAdjList}-[func]{}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u8868 9-2 \u5bf9\u6bd4\u4e86\u90bb\u63a5\u77e9\u9635\u548c\u90bb\u63a5\u8868\u7684\u65f6\u95f4\u6548\u7387\u548c\u7a7a\u95f4\u6548\u7387\u3002

    \u8868 9-2 \u00a0 \u90bb\u63a5\u77e9\u9635\u4e0e\u90bb\u63a5\u8868\u5bf9\u6bd4

    \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\u8868 9-2 \uff0c\u4f3c\u4e4e\u90bb\u63a5\u8868\uff08\u54c8\u5e0c\u8868\uff09\u7684\u65f6\u95f4\u6548\u7387\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\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":"

    \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\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\u3002

    \u56fe\u548c\u6811\u90fd\u9700\u8981\u5e94\u7528\u641c\u7d22\u7b97\u6cd5\u6765\u5b9e\u73b0\u904d\u5386\u64cd\u4f5c\u3002\u56fe\u7684\u904d\u5386\u65b9\u5f0f\u4e5f\u53ef\u5206\u4e3a\u4e24\u79cd\uff1a\u300c\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u300d\u548c\u300c\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u300d\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\u67d0\u4e2a\u8282\u70b9\u51fa\u53d1\uff0c\u59cb\u7ec8\u4f18\u5148\u8bbf\u95ee\u8ddd\u79bb\u6700\u8fd1\u7684\u9876\u70b9\uff0c\u5e76\u4e00\u5c42\u5c42\u5411\u5916\u6269\u5f20\u3002\u5982\u56fe 9-9 \u6240\u793a\uff0c\u4ece\u5de6\u4e0a\u89d2\u9876\u70b9\u51fa\u53d1\uff0c\u9996\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

    \u56fe 9-9 \u00a0 \u56fe\u7684\u5e7f\u5ea6\u4f18\u5148\u904d\u5386

    "},{"location":"chapter_graph/graph_traversal/#1","title":"1. \u00a0 \u7b97\u6cd5\u5b9e\u73b0","text":"

    BFS \u901a\u5e38\u501f\u52a9\u961f\u5217\u6765\u5b9e\u73b0\uff0c\u4ee3\u7801\u5982\u4e0b\u6240\u793a\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\u3002
    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\u3002
    3. \u5faa\u73af\u6b65\u9aa4 2. \uff0c\u76f4\u5230\u6240\u6709\u9876\u70b9\u88ab\u8bbf\u95ee\u5b8c\u6bd5\u540e\u7ed3\u675f\u3002

    \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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_bfs.py
    def graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n    \"\"\"\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\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\n    res = []\n    # \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited = set[Vertex]([start_vet])\n    # \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    que = deque[Vertex]([start_vet])\n    # \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while len(que) > 0:\n        vet = que.popleft()  # \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        # \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for adj_vet in graph.adj_list[vet]:\n            if adj_vet in visited:\n                continue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.append(adj_vet)  # \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adj_vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    # \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n
    graph_bfs.cpp
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    vector<Vertex *> res;\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    unordered_set<Vertex *> visited = {startVet};\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    queue<Vertex *> que;\n    que.push(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.empty()) {\n        Vertex *vet = que.front();\n        que.pop();          // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push_back(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (auto adjVet : graph.adjList[vet]) {\n            if (visited.count(adjVet))\n                continue;            // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.push(adjVet);        // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.emplace(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.java
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = new ArrayList<>();\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    Set<Vertex> visited = new HashSet<>();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue<Vertex> que = new LinkedList<>();\n    que.offer(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.isEmpty()) {\n        Vertex vet = que.poll(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.add(vet);            // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (Vertex adjVet : graph.adjList.get(vet)) {\n            if (visited.contains(adjVet))\n                continue;        // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            que.offer(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.cs
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    HashSet<Vertex> visited = [startVet];\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue<Vertex> que = new();\n    que.Enqueue(startVet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.Count > 0) {\n        Vertex vet = que.Dequeue(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.Add(vet);               // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        foreach (Vertex adjVet in graph.adjList[vet]) {\n            if (visited.Contains(adjVet)) {\n                continue;          // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.Enqueue(adjVet);   // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.Add(adjVet);   // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.go
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    res := make([]Vertex, 0)\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited := make(map[Vertex]struct{})\n    visited[startVet] = struct{}{}\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS, \u4f7f\u7528\u5207\u7247\u6a21\u62df\u961f\u5217\n    queue := make([]Vertex, 0)\n    queue = append(queue, startVet)\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    for len(queue) > 0 {\n        // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        vet := queue[0]\n        queue = queue[1:]\n        // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        res = append(res, vet)\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for _, adjVet := range g.adjList[vet] {\n            _, isExist := visited[adjVet]\n            // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            if !isExist {\n                queue = append(queue, adjVet)\n                visited[adjVet] = struct{}{}\n            }\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.swift
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    var res: [Vertex] = []\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    var visited: Set<Vertex> = [startVet]\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    var que: [Vertex] = [startVet]\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while !que.isEmpty {\n        let vet = que.removeFirst() // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for adjVet in graph.adjList[vet] ?? [] {\n            if visited.contains(adjVet) {\n                continue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.append(adjVet) // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.insert(adjVet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.js
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited = new Set();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    const que = [startVet];\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.length) {\n        const vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.ts
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res: Vertex[] = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited: Set<Vertex> = new Set();\n    visited.add(startVet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    const que = [startVet];\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (que.length) {\n        const vet = que.shift(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (const adjVet of graph.adjList.get(vet) ?? []) {\n            if (visited.has(adjVet)) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            que.push(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\n            visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res;\n}\n
    graph_bfs.dart
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\n  List<Vertex> res = [];\n  // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n  Set<Vertex> visited = {};\n  visited.add(startVet);\n  // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n  Queue<Vertex> que = Queue();\n  que.add(startVet);\n  // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n  while (que.isNotEmpty) {\n    Vertex vet = que.removeFirst(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n    res.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex adjVet in graph.adjList[vet]!) {\n      if (visited.contains(adjVet)) {\n        continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n      }\n      que.add(adjVet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n      visited.add(adjVet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    }\n  }\n  // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n  return res;\n}\n
    graph_bfs.rs
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfn graph_bfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    let mut res = vec![];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    let mut visited = HashSet::new();\n    visited.insert(start_vet);\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    let mut que = VecDeque::new();\n    que.push_back(start_vet);\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while !que.is_empty() {\n        let vet = que.pop_front().unwrap(); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        if let Some(adj_vets) = graph.adj_list.get(&vet) {\n            for &adj_vet in adj_vets {\n                if visited.contains(&adj_vet) {\n                    continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n                }\n                que.push_back(adj_vet); // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n                visited.insert(adj_vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n            }\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    res\n}\n
    graph_bfs.c
    /* \u8282\u70b9\u961f\u5217\u7ed3\u6784\u4f53 */\ntypedef struct {\n    Vertex *vertices[MAX_SIZE];\n    int front, rear, size;\n} Queue;\n\n/* \u6784\u9020\u51fd\u6570 */\nQueue *newQueue() {\n    Queue *q = (Queue *)malloc(sizeof(Queue));\n    q->front = q->rear = q->size = 0;\n    return q;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nint isEmpty(Queue *q) {\n    return q->size == 0;\n}\n\n/* \u5165\u961f\u64cd\u4f5c */\nvoid enqueue(Queue *q, Vertex *vet) {\n    q->vertices[q->rear] = vet;\n    q->rear = (q->rear + 1) % MAX_SIZE;\n    q->size++;\n}\n\n/* \u51fa\u961f\u64cd\u4f5c */\nVertex *dequeue(Queue *q) {\n    Vertex *vet = q->vertices[q->front];\n    q->front = (q->front + 1) % MAX_SIZE;\n    q->size--;\n    return vet;\n}\n\n/* \u68c0\u67e5\u9876\u70b9\u662f\u5426\u5df2\u88ab\u8bbf\u95ee */\nint isVisited(Vertex **visited, int size, Vertex *vet) {\n    // \u904d\u5386\u67e5\u627e\u8282\u70b9\uff0c\u4f7f\u7528 O(n) \u65f6\u95f4\n    for (int i = 0; i < size; i++) {\n        if (visited[i] == vet)\n            return 1;\n    }\n    return 0;\n}\n\n/* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nvoid graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    Queue *queue = newQueue();\n    enqueue(queue, startVet);\n    visited[(*visitedSize)++] = startVet;\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!isEmpty(queue)) {\n        Vertex *vet = dequeue(queue); // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res[(*resSize)++] = vet;      // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        AdjListNode *node = findNode(graph, vet);\n        while (node != NULL) {\n            // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            if (!isVisited(visited, *visitedSize, node->vertex)) {\n                enqueue(queue, node->vertex);             // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n                visited[(*visitedSize)++] = node->vertex; // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n            }\n            node = node->next;\n        }\n    }\n    // \u91ca\u653e\u5185\u5b58\n    free(queue);\n}\n
    graph_bfs.kt
    /* \u5e7f\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfun graphBFS(graph: GraphAdjList, startVet: Vertex): List<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    val res: MutableList<Vertex> = ArrayList()\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    val visited: MutableSet<Vertex> = HashSet()\n    visited.add(startVet)\n    // \u961f\u5217\u7528\u4e8e\u5b9e\u73b0 BFS\n    val que: Queue<Vertex> = LinkedList()\n    que.offer(startVet)\n    // \u4ee5\u9876\u70b9 vet \u4e3a\u8d77\u70b9\uff0c\u5faa\u73af\u76f4\u81f3\u8bbf\u95ee\u5b8c\u6240\u6709\u9876\u70b9\n    while (!que.isEmpty()) {\n        val vet = que.poll() // \u961f\u9996\u9876\u70b9\u51fa\u961f\n        res.add(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n        // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n        for (adjVet in graph.adjList[vet]!!) {\n            if (visited.contains(adjVet)) continue  // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n\n            que.offer(adjVet) // \u53ea\u5165\u961f\u672a\u8bbf\u95ee\u7684\u9876\u70b9\n            visited.add(adjVet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n        }\n    }\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_bfs.rb
    [class]{}-[func]{graph_bfs}\n
    graph_bfs.zig
    [class]{}-[func]{graphBFS}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u4ee3\u7801\u76f8\u5bf9\u62bd\u8c61\uff0c\u5efa\u8bae\u5bf9\u7167\u56fe 9-10 \u6765\u52a0\u6df1\u7406\u89e3\u3002

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

    \u56fe 9-10 \u00a0 \u56fe\u7684\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u6b65\u9aa4

    \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\u5141\u8bb8\u88ab\u4efb\u610f\u6253\u4e71\u3002\u4ee5\u56fe 9-10 \u4e3a\u4f8b\uff0c\u9876\u70b9 \\(1\\)\u3001\\(3\\) \u7684\u8bbf\u95ee\u987a\u5e8f\u53ef\u4ee5\u4ea4\u6362\uff0c\u9876\u70b9 \\(2\\)\u3001\\(4\\)\u3001\\(6\\) \u7684\u8bbf\u95ee\u987a\u5e8f\u4e5f\u53ef\u4ee5\u4efb\u610f\u4ea4\u6362\u3002

    "},{"location":"chapter_graph/graph_traversal/#2","title":"2. \u00a0 \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\u5982\u56fe 9-11 \u6240\u793a\uff0c\u4ece\u5de6\u4e0a\u89d2\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

    \u56fe 9-11 \u00a0 \u56fe\u7684\u6df1\u5ea6\u4f18\u5148\u904d\u5386

    "},{"location":"chapter_graph/graph_traversal/#1_1","title":"1. \u00a0 \u7b97\u6cd5\u5b9e\u73b0","text":"

    \u8fd9\u79cd\u201c\u8d70\u5230\u5c3d\u5934\u518d\u8fd4\u56de\u201d\u7684\u7b97\u6cd5\u8303\u5f0f\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u6765\u5b9e\u73b0\u3002\u4e0e\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u7c7b\u4f3c\uff0c\u5728\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u4e2d\uff0c\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig graph_dfs.py
    def dfs(graph: GraphAdjList, visited: set[Vertex], res: list[Vertex], vet: Vertex):\n    \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570\"\"\"\n    res.append(vet)  # \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet)  # \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    # \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for adjVet in graph.adj_list[vet]:\n        if adjVet in visited:\n            continue  # \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        # \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet)\n\ndef graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> list[Vertex]:\n    \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\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\n    res = []\n    # \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited = set[Vertex]()\n    dfs(graph, visited, res, start_vet)\n    return res\n
    graph_dfs.cpp
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {\n    res.push_back(vet);   // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.emplace(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex *adjVet : graph.adjList[vet]) {\n        if (visited.count(adjVet))\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    vector<Vertex *> res;\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    unordered_set<Vertex *> visited;\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.java
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList graph, Set<Vertex> visited, List<Vertex> res, Vertex vet) {\n    res.add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (Vertex adjVet : graph.adjList.get(vet)) {\n        if (visited.contains(adjVet))\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = new ArrayList<>();\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    Set<Vertex> visited = new HashSet<>();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.cs
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid DFS(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {\n    res.Add(vet);     // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.Add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    foreach (Vertex adjVet in graph.adjList[vet]) {\n        if (visited.Contains(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9                             \n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        DFS(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    List<Vertex> res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    HashSet<Vertex> visited = [];\n    DFS(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.go
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\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)\n    visited[vet] = struct{}{}\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for _, adjVet := range g.adjList[vet] {\n        _, isExist := visited[adjVet]\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        if !isExist {\n            dfs(g, visited, res, adjVet)\n        }\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    res := make([]Vertex, 0)\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    visited := make(map[Vertex]struct{})\n    dfs(g, visited, &res, startVet)\n    // \u8fd4\u56de\u9876\u70b9\u904d\u5386\u5e8f\u5217\n    return res\n}\n
    graph_dfs.swift
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfunc dfs(graph: GraphAdjList, visited: inout Set<Vertex>, res: inout [Vertex], vet: Vertex) {\n    res.append(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.insert(vet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for adjVet in graph.adjList[vet] ?? [] {\n        if visited.contains(adjVet) {\n            continue // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph: graph, visited: &visited, res: &res, vet: adjVet)\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    var res: [Vertex] = []\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    var visited: Set<Vertex> = []\n    dfs(graph: graph, visited: &visited, res: &res, vet: startVet)\n    return res\n}\n
    graph_dfs.js
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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) {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.ts
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfunction dfs(\n    graph: GraphAdjList,\n    visited: Set<Vertex>,\n    res: Vertex[],\n    vet: Vertex\n): void {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (const adjVet of graph.adjList.get(vet)) {\n        if (visited.has(adjVet)) {\n            continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        }\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet);\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\n    const res: Vertex[] = [];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    const visited: Set<Vertex> = new Set();\n    dfs(graph, visited, res, startVet);\n    return res;\n}\n
    graph_dfs.dart
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(\n  GraphAdjList graph,\n  Set<Vertex> visited,\n  List<Vertex> res,\n  Vertex vet,\n) {\n  res.add(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n  visited.add(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n  // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n  for (Vertex adjVet in graph.adjList[vet]!) {\n    if (visited.contains(adjVet)) {\n      continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n    }\n    // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n    dfs(graph, visited, res, adjVet);\n  }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nList<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {\n  // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n  List<Vertex> res = [];\n  // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n  Set<Vertex> visited = {};\n  dfs(graph, visited, res, startVet);\n  return res;\n}\n
    graph_dfs.rs
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfn dfs(graph: &GraphAdjList, visited: &mut HashSet<Vertex>, res: &mut Vec<Vertex>, vet: Vertex) {\n    res.push(vet); // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.insert(vet); // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n                         // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    if let Some(adj_vets) = graph.adj_list.get(&vet) {\n        for &adj_vet in adj_vets {\n            if visited.contains(&adj_vet) {\n                continue; // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n            }\n            // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n            dfs(graph, visited, res, adj_vet);\n        }\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfn graph_dfs(graph: GraphAdjList, start_vet: Vertex) -> Vec<Vertex> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    let mut res = vec![];\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    let mut visited = HashSet::new();\n    dfs(&graph, &mut visited, &mut res, start_vet);\n\n    res\n}\n
    graph_dfs.c
    /* \u68c0\u67e5\u9876\u70b9\u662f\u5426\u5df2\u88ab\u8bbf\u95ee */\nint isVisited(Vertex **res, int size, Vertex *vet) {\n    // \u904d\u5386\u67e5\u627e\u8282\u70b9\uff0c\u4f7f\u7528 O(n) \u65f6\u95f4\n    for (int i = 0; i < size; i++) {\n        if (res[i] == vet) {\n            return 1;\n        }\n    }\n    return 0;\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nvoid dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {\n    // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    res[(*resSize)++] = vet;\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    AdjListNode *node = findNode(graph, vet);\n    while (node != NULL) {\n        // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        if (!isVisited(res, *resSize, node->vertex)) {\n            // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n            dfs(graph, res, resSize, node->vertex);\n        }\n        node = node->next;\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nvoid graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {\n    dfs(graph, res, resSize, startVet);\n}\n
    graph_dfs.kt
    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u8f85\u52a9\u51fd\u6570 */\nfun dfs(\n    graph: GraphAdjList,\n    visited: MutableSet<Vertex?>,\n    res: MutableList<Vertex?>,\n    vet: Vertex?\n) {\n    res.add(vet) // \u8bb0\u5f55\u8bbf\u95ee\u9876\u70b9\n    visited.add(vet) // \u6807\u8bb0\u8be5\u9876\u70b9\u5df2\u88ab\u8bbf\u95ee\n    // \u904d\u5386\u8be5\u9876\u70b9\u7684\u6240\u6709\u90bb\u63a5\u9876\u70b9\n    for (adjVet in graph.adjList[vet]!!) {\n        if (visited.contains(adjVet)) continue  // \u8df3\u8fc7\u5df2\u88ab\u8bbf\u95ee\u7684\u9876\u70b9\n        // \u9012\u5f52\u8bbf\u95ee\u90bb\u63a5\u9876\u70b9\n        dfs(graph, visited, res, adjVet)\n    }\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\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\nfun graphDFS(\n    graph: GraphAdjList,\n    startVet: Vertex?\n): List<Vertex?> {\n    // \u9876\u70b9\u904d\u5386\u5e8f\u5217\n    val res: MutableList<Vertex?> = ArrayList()\n    // \u54c8\u5e0c\u8868\uff0c\u7528\u4e8e\u8bb0\u5f55\u5df2\u88ab\u8bbf\u95ee\u8fc7\u7684\u9876\u70b9\n    val visited: MutableSet<Vertex?> = HashSet()\n    dfs(graph, visited, res, startVet)\n    return res\n}\n
    graph_dfs.rb
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{graph_dfs}\n
    graph_dfs.zig
    [class]{}-[func]{dfs}\n\n[class]{}-[func]{graphDFS}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u7b97\u6cd5\u6d41\u7a0b\u5982\u56fe 9-12 \u6240\u793a\u3002

    • \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\u3002
    • \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\u65b9\u6cd5\u7684\u4f4d\u7f6e\u3002

    \u4e3a\u4e86\u52a0\u6df1\u7406\u89e3\uff0c\u5efa\u8bae\u5c06\u56fe 9-12 \u4e0e\u4ee3\u7801\u7ed3\u5408\u8d77\u6765\uff0c\u5728\u8111\u4e2d\u6a21\u62df\uff08\u6216\u8005\u7528\u7b14\u753b\u4e0b\u6765\uff09\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>

    \u56fe 9-12 \u00a0 \u56fe\u7684\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u6b65\u9aa4

    \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\u201c\u5de6 \\(\\rightarrow\\) \u6839 \\(\\rightarrow\\) \u53f3\u201d\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\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/#2_1","title":"2. \u00a0 \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":""},{"location":"chapter_graph/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","text":"
    • \u56fe\u7531\u9876\u70b9\u548c\u8fb9\u7ec4\u6210\uff0c\u53ef\u4ee5\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\u6539\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\\) \u4e2a\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\u56e0\u6b64\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\u7684\u89d2\u5ea6\u5206\u6790\uff0c\u90bb\u63a5\u77e9\u9635\u4f53\u73b0\u4e86\u201c\u4ee5\u7a7a\u95f4\u6362\u65f6\u95f4\u201d\uff0c\u90bb\u63a5\u8868\u4f53\u73b0\u4e86\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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u89c6\u4e3a\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

    Q\uff1a\u975e\u8fde\u901a\u56fe\u4e2d\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

    Q\uff1a\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\u9700\u8981\u6309\u7167\u6307\u5b9a\u89c4\u5219\u6765\u6392\u5e8f\uff0c\u6bd4\u5982\u6309\u7167\u9876\u70b9\u6dfb\u52a0\u7684\u6b21\u5e8f\uff0c\u6216\u8005\u6309\u7167\u9876\u70b9\u503c\u5927\u5c0f\u7684\u987a\u5e8f\u7b49\uff0c\u8fd9\u6837\u6709\u52a9\u4e8e\u5feb\u901f\u67e5\u627e\u201c\u5e26\u6709\u67d0\u79cd\u6781\u503c\u201d\u7684\u9876\u70b9\u3002

    "},{"location":"chapter_greedy/","title":"\u7b2c 15 \u7ae0 \u00a0 \u8d2a\u5fc3","text":"

    Abstract

    \u5411\u65e5\u8475\u671d\u7740\u592a\u9633\u8f6c\u52a8\uff0c\u65f6\u523b\u8ffd\u6c42\u81ea\u8eab\u6210\u957f\u7684\u6700\u5927\u53ef\u80fd\u3002

    \u8d2a\u5fc3\u7b56\u7565\u5728\u4e00\u8f6e\u8f6e\u7684\u7b80\u5355\u9009\u62e9\u4e2d\uff0c\u9010\u6b65\u5bfc\u5411\u6700\u4f73\u7b54\u6848\u3002

    "},{"location":"chapter_greedy/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 15.1 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5
    • 15.2 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898
    • 15.3 \u00a0 \u6700\u5927\u5bb9\u91cf\u95ee\u9898
    • 15.4 \u00a0 \u6700\u5927\u5207\u5206\u4e58\u79ef\u95ee\u9898
    • 15.5 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_greedy/fractional_knapsack_problem/","title":"15.2 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898","text":"

    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\u548c\u4e00\u4e2a\u5bb9\u91cf\u4e3a \\(cap\\) \u7684\u80cc\u5305\u3002\u6bcf\u4e2a\u7269\u54c1\u53ea\u80fd\u9009\u62e9\u4e00\u6b21\uff0c\u4f46\u53ef\u4ee5\u9009\u62e9\u7269\u54c1\u7684\u4e00\u90e8\u5206\uff0c\u4ef7\u503c\u6839\u636e\u9009\u62e9\u7684\u91cd\u91cf\u6bd4\u4f8b\u8ba1\u7b97\uff0c\u95ee\u5728\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u80cc\u5305\u4e2d\u7269\u54c1\u7684\u6700\u5927\u4ef7\u503c\u3002\u793a\u4f8b\u5982\u56fe 15-3 \u6240\u793a\u3002

    \u56fe 15-3 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    \u5206\u6570\u80cc\u5305\u95ee\u9898\u548c 0-1 \u80cc\u5305\u95ee\u9898\u6574\u4f53\u4e0a\u975e\u5e38\u76f8\u4f3c\uff0c\u72b6\u6001\u5305\u542b\u5f53\u524d\u7269\u54c1 \\(i\\) \u548c\u5bb9\u91cf \\(c\\) \uff0c\u76ee\u6807\u662f\u6c42\u9650\u5b9a\u80cc\u5305\u5bb9\u91cf\u4e0b\u7684\u6700\u5927\u4ef7\u503c\u3002

    \u4e0d\u540c\u70b9\u5728\u4e8e\uff0c\u672c\u9898\u5141\u8bb8\u53ea\u9009\u62e9\u7269\u54c1\u7684\u4e00\u90e8\u5206\u3002\u5982\u56fe 15-4 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5bf9\u7269\u54c1\u4efb\u610f\u5730\u8fdb\u884c\u5207\u5206\uff0c\u5e76\u6309\u7167\u91cd\u91cf\u6bd4\u4f8b\u6765\u8ba1\u7b97\u76f8\u5e94\u4ef7\u503c\u3002

    1. \u5bf9\u4e8e\u7269\u54c1 \\(i\\) \uff0c\u5b83\u5728\u5355\u4f4d\u91cd\u91cf\u4e0b\u7684\u4ef7\u503c\u4e3a \\(val[i-1] / wgt[i-1]\\) \uff0c\u7b80\u79f0\u5355\u4f4d\u4ef7\u503c\u3002
    2. \u5047\u8bbe\u653e\u5165\u4e00\u90e8\u5206\u7269\u54c1 \\(i\\) \uff0c\u91cd\u91cf\u4e3a \\(w\\) \uff0c\u5219\u80cc\u5305\u589e\u52a0\u7684\u4ef7\u503c\u4e3a \\(w \\times val[i-1] / wgt[i-1]\\) \u3002

    \u56fe 15-4 \u00a0 \u7269\u54c1\u5728\u5355\u4f4d\u91cd\u91cf\u4e0b\u7684\u4ef7\u503c

    "},{"location":"chapter_greedy/fractional_knapsack_problem/#1","title":"1. \u00a0 \u8d2a\u5fc3\u7b56\u7565\u786e\u5b9a","text":"

    \u6700\u5927\u5316\u80cc\u5305\u5185\u7269\u54c1\u603b\u4ef7\u503c\uff0c\u672c\u8d28\u4e0a\u662f\u6700\u5927\u5316\u5355\u4f4d\u91cd\u91cf\u4e0b\u7684\u7269\u54c1\u4ef7\u503c\u3002\u7531\u6b64\u4fbf\u53ef\u63a8\u7406\u51fa\u56fe 15-5 \u6240\u793a\u7684\u8d2a\u5fc3\u7b56\u7565\u3002

    1. \u5c06\u7269\u54c1\u6309\u7167\u5355\u4f4d\u4ef7\u503c\u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\u3002
    2. \u904d\u5386\u6240\u6709\u7269\u54c1\uff0c\u6bcf\u8f6e\u8d2a\u5fc3\u5730\u9009\u62e9\u5355\u4f4d\u4ef7\u503c\u6700\u9ad8\u7684\u7269\u54c1\u3002
    3. \u82e5\u5269\u4f59\u80cc\u5305\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u4f7f\u7528\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u586b\u6ee1\u80cc\u5305\u3002

    \u56fe 15-5 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898\u7684\u8d2a\u5fc3\u7b56\u7565

    "},{"location":"chapter_greedy/fractional_knapsack_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u6211\u4eec\u5efa\u7acb\u4e86\u4e00\u4e2a\u7269\u54c1\u7c7b Item \uff0c\u4ee5\u4fbf\u5c06\u7269\u54c1\u6309\u7167\u5355\u4f4d\u4ef7\u503c\u8fdb\u884c\u6392\u5e8f\u3002\u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u5f53\u80cc\u5305\u5df2\u6ee1\u65f6\u8df3\u51fa\u5e76\u8fd4\u56de\u89e3\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig fractional_knapsack.py
    class Item:\n    \"\"\"\u7269\u54c1\"\"\"\n\n    def __init__(self, w: int, v: int):\n        self.w = w  # \u7269\u54c1\u91cd\u91cf\n        self.v = v  # \u7269\u54c1\u4ef7\u503c\n\ndef fractional_knapsack(wgt: list[int], val: list[int], cap: int) -> int:\n    \"\"\"\u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3\"\"\"\n    # \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    items = [Item(w, v) for w, v in zip(wgt, val)]\n    # \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort(key=lambda item: item.v / item.w, reverse=True)\n    # \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    res = 0\n    for item in items:\n        if item.w <= cap:\n            # \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v\n            cap -= item.w\n        else:\n            # \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (item.v / item.w) * cap\n            # \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n    return res\n
    fractional_knapsack.cpp
    /* \u7269\u54c1 */\nclass Item {\n  public:\n    int w; // \u7269\u54c1\u91cd\u91cf\n    int v; // \u7269\u54c1\u4ef7\u503c\n\n    Item(int w, int v) : w(w), v(v) {\n    }\n};\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\ndouble fractionalKnapsack(vector<int> &wgt, vector<int> &val, int cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    vector<Item> items;\n    for (int i = 0; i < wgt.size(); i++) {\n        items.push_back(Item(wgt[i], val[i]));\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    sort(items.begin(), items.end(), [](Item &a, Item &b) { return (double)a.v / a.w > (double)b.v / b.w; });\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    double res = 0;\n    for (auto &item : items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (double)item.v / item.w * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.java
    /* \u7269\u54c1 */\nclass Item {\n    int w; // \u7269\u54c1\u91cd\u91cf\n    int v; // \u7269\u54c1\u4ef7\u503c\n\n    public Item(int w, int v) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\ndouble fractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    Item[] items = new Item[wgt.length];\n    for (int i = 0; i < wgt.length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    Arrays.sort(items, Comparator.comparingDouble(item -> -((double) item.v / item.w)));\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    double res = 0;\n    for (Item item : items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (double) item.v / item.w * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.cs
    /* \u7269\u54c1 */\nclass Item(int w, int v) {\n    public int w = w; // \u7269\u54c1\u91cd\u91cf\n    public int v = v; // \u7269\u54c1\u4ef7\u503c\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\ndouble FractionalKnapsack(int[] wgt, int[] val, int cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    Item[] items = new Item[wgt.Length];\n    for (int i = 0; i < wgt.Length; i++) {\n        items[i] = new Item(wgt[i], val[i]);\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    Array.Sort(items, (x, y) => (y.v / y.w).CompareTo(x.v / x.w));\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    double res = 0;\n    foreach (Item item in items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (double)item.v / item.w * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.go
    /* \u7269\u54c1 */\ntype Item struct {\n    w int // \u7269\u54c1\u91cd\u91cf\n    v int // \u7269\u54c1\u4ef7\u503c\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfunc fractionalKnapsack(wgt []int, val []int, cap int) float64 {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    items := make([]Item, len(wgt))\n    for i := 0; i < len(wgt); i++ {\n        items[i] = Item{wgt[i], val[i]}\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    sort.Slice(items, func(i, j int) bool {\n        return float64(items[i].v)/float64(items[i].w) > float64(items[j].v)/float64(items[j].w)\n    })\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    res := 0.0\n    for _, item := range items {\n        if item.w <= cap {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += float64(item.v)\n            cap -= item.w\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += float64(item.v) / float64(item.w) * float64(cap)\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    return res\n}\n
    fractional_knapsack.swift
    /* \u7269\u54c1 */\nclass Item {\n    var w: Int // \u7269\u54c1\u91cd\u91cf\n    var v: Int // \u7269\u54c1\u4ef7\u503c\n\n    init(w: Int, v: Int) {\n        self.w = w\n        self.v = v\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfunc fractionalKnapsack(wgt: [Int], val: [Int], cap: Int) -> Double {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    var items = zip(wgt, val).map { Item(w: $0, v: $1) }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort { -(Double($0.v) / Double($0.w)) < -(Double($1.v) / Double($1.w)) }\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    var res = 0.0\n    var cap = cap\n    for item in items {\n        if item.w <= cap {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += Double(item.v)\n            cap -= item.w\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += Double(item.v) / Double(item.w) * Double(cap)\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    return res\n}\n
    fractional_knapsack.js
    /* \u7269\u54c1 */\nclass Item {\n    constructor(w, v) {\n        this.w = w; // \u7269\u54c1\u91cd\u91cf\n        this.v = v; // \u7269\u54c1\u4ef7\u503c\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfunction fractionalKnapsack(wgt, val, cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    const items = wgt.map((w, i) => new Item(w, val[i]));\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort((a, b) => b.v / b.w - a.v / a.w);\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    let res = 0;\n    for (const item of items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (item.v / item.w) * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.ts
    /* \u7269\u54c1 */\nclass Item {\n    w: number; // \u7269\u54c1\u91cd\u91cf\n    v: number; // \u7269\u54c1\u4ef7\u503c\n\n    constructor(w: number, v: number) {\n        this.w = w;\n        this.v = v;\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfunction fractionalKnapsack(wgt: number[], val: number[], cap: number): number {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    const items: Item[] = wgt.map((w, i) => new Item(w, val[i]));\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort((a, b) => b.v / b.w - a.v / a.w);\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    let res = 0;\n    for (const item of items) {\n        if (item.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (item.v / item.w) * cap;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    return res;\n}\n
    fractional_knapsack.dart
    /* \u7269\u54c1 */\nclass Item {\n  int w; // \u7269\u54c1\u91cd\u91cf\n  int v; // \u7269\u54c1\u4ef7\u503c\n\n  Item(this.w, this.v);\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\ndouble fractionalKnapsack(List<int> wgt, List<int> val, int cap) {\n  // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n  List<Item> items = List.generate(wgt.length, (i) => Item(wgt[i], val[i]));\n  // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n  items.sort((a, b) => (b.v / b.w).compareTo(a.v / a.w));\n  // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n  double res = 0;\n  for (Item item in items) {\n    if (item.w <= cap) {\n      // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n      res += item.v;\n      cap -= item.w;\n    } else {\n      // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n      res += item.v / item.w * cap;\n      // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n      break;\n    }\n  }\n  return res;\n}\n
    fractional_knapsack.rs
    /* \u7269\u54c1 */\nstruct Item {\n    w: i32, // \u7269\u54c1\u91cd\u91cf\n    v: i32, // \u7269\u54c1\u4ef7\u503c\n}\n\nimpl Item {\n    fn new(w: i32, v: i32) -> Self {\n        Self { w, v }\n    }\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfn fractional_knapsack(wgt: &[i32], val: &[i32], mut cap: i32) -> f64 {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    let mut items = wgt\n        .iter()\n        .zip(val.iter())\n        .map(|(&w, &v)| Item::new(w, v))\n        .collect::<Vec<Item>>();\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    items.sort_by(|a, b| {\n        (b.v as f64 / b.w as f64)\n            .partial_cmp(&(a.v as f64 / a.w as f64))\n            .unwrap()\n    });\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    let mut res = 0.0;\n    for item in &items {\n        if item.w <= cap {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v as f64;\n            cap -= item.w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += item.v as f64 / item.w as f64 * cap as f64;\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    res\n}\n
    fractional_knapsack.c
    /* \u7269\u54c1 */\ntypedef struct {\n    int w; // \u7269\u54c1\u91cd\u91cf\n    int v; // \u7269\u54c1\u4ef7\u503c\n} Item;\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfloat fractionalKnapsack(int wgt[], int val[], int itemCount, int cap) {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    Item *items = malloc(sizeof(Item) * itemCount);\n    for (int i = 0; i < itemCount; i++) {\n        items[i] = (Item){.w = wgt[i], .v = val[i]};\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    qsort(items, (size_t)itemCount, sizeof(Item), sortByValueDensity);\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    float res = 0.0;\n    for (int i = 0; i < itemCount; i++) {\n        if (items[i].w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += items[i].v;\n            cap -= items[i].w;\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += (float)cap / items[i].w * items[i].v;\n            cap = 0;\n            break;\n        }\n    }\n    free(items);\n    return res;\n}\n
    fractional_knapsack.kt
    /* \u7269\u54c1 */\nclass Item(\n    val w: Int, // \u7269\u54c1\n    val v: Int // \u7269\u54c1\u4ef7\u503c\n)\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfun fractionalKnapsack(\n    wgt: IntArray,\n    value: IntArray,\n    c: Int\n): Double {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    var cap = c\n    val items = arrayOfNulls<Item>(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], value[i])\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    Arrays.sort(items, Comparator.comparingDouble { item: Item -> -(item.v.toDouble() / item.w) })\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v.toDouble()\n            cap -= item.w\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += item.v.toDouble() / item.w * cap\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    return res\n}\n\n/* \u5206\u6570\u80cc\u5305\uff1a\u8d2a\u5fc3 */\nfun fractionalKnapsack(\n    wgt: IntArray,\n    value: IntArray,\n    c: Int\n): Double {\n    // \u521b\u5efa\u7269\u54c1\u5217\u8868\uff0c\u5305\u542b\u4e24\u4e2a\u5c5e\u6027\uff1a\u91cd\u91cf\u3001\u4ef7\u503c\n    var cap = c\n    val items = arrayOfNulls<Item>(wgt.size)\n    for (i in wgt.indices) {\n        items[i] = Item(wgt[i], value[i])\n    }\n    // \u6309\u7167\u5355\u4f4d\u4ef7\u503c item.v / item.w \u4ece\u9ad8\u5230\u4f4e\u8fdb\u884c\u6392\u5e8f\n    Arrays.sort(items, Comparator.comparingDouble { item: Item -> -(item.v.toDouble() / item.w) })\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\n    var res = 0.0\n    for (item in items) {\n        if (item!!.w <= cap) {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u5145\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u6574\u4e2a\u88c5\u8fdb\u80cc\u5305\n            res += item.v.toDouble()\n            cap -= item.w\n        } else {\n            // \u82e5\u5269\u4f59\u5bb9\u91cf\u4e0d\u8db3\uff0c\u5219\u5c06\u5f53\u524d\u7269\u54c1\u7684\u4e00\u90e8\u5206\u88c5\u8fdb\u80cc\u5305\n            res += item.v.toDouble() / item.w * cap\n            // \u5df2\u65e0\u5269\u4f59\u5bb9\u91cf\uff0c\u56e0\u6b64\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    return res\n}\n
    fractional_knapsack.rb
    [class]{Item}-[func]{}\n\n[class]{}-[func]{fractional_knapsack}\n
    fractional_knapsack.zig
    [class]{Item}-[func]{}\n\n[class]{}-[func]{fractionalKnapsack}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u9664\u6392\u5e8f\u4e4b\u5916\uff0c\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u9700\u8981\u904d\u5386\u6574\u4e2a\u7269\u54c1\u5217\u8868\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff0c\u5176\u4e2d \\(n\\) \u4e3a\u7269\u54c1\u6570\u91cf\u3002

    \u7531\u4e8e\u521d\u59cb\u5316\u4e86\u4e00\u4e2a Item \u5bf9\u8c61\u5217\u8868\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    "},{"location":"chapter_greedy/fractional_knapsack_problem/#3","title":"3. \u00a0 \u6b63\u786e\u6027\u8bc1\u660e","text":"

    \u91c7\u7528\u53cd\u8bc1\u6cd5\u3002\u5047\u8bbe\u7269\u54c1 \\(x\\) \u662f\u5355\u4f4d\u4ef7\u503c\u6700\u9ad8\u7684\u7269\u54c1\uff0c\u4f7f\u7528\u67d0\u7b97\u6cd5\u6c42\u5f97\u6700\u5927\u4ef7\u503c\u4e3a res \uff0c\u4f46\u8be5\u89e3\u4e2d\u4e0d\u5305\u542b\u7269\u54c1 \\(x\\) \u3002

    \u73b0\u5728\u4ece\u80cc\u5305\u4e2d\u62ff\u51fa\u5355\u4f4d\u91cd\u91cf\u7684\u4efb\u610f\u7269\u54c1\uff0c\u5e76\u66ff\u6362\u4e3a\u5355\u4f4d\u91cd\u91cf\u7684\u7269\u54c1 \\(x\\) \u3002\u7531\u4e8e\u7269\u54c1 \\(x\\) \u7684\u5355\u4f4d\u4ef7\u503c\u6700\u9ad8\uff0c\u56e0\u6b64\u66ff\u6362\u540e\u7684\u603b\u4ef7\u503c\u4e00\u5b9a\u5927\u4e8e res \u3002\u8fd9\u4e0e res \u662f\u6700\u4f18\u89e3\u77db\u76fe\uff0c\u8bf4\u660e\u6700\u4f18\u89e3\u4e2d\u5fc5\u987b\u5305\u542b\u7269\u54c1 \\(x\\) \u3002

    \u5bf9\u4e8e\u8be5\u89e3\u4e2d\u7684\u5176\u4ed6\u7269\u54c1\uff0c\u6211\u4eec\u4e5f\u53ef\u4ee5\u6784\u5efa\u51fa\u4e0a\u8ff0\u77db\u76fe\u3002\u603b\u800c\u8a00\u4e4b\uff0c\u5355\u4f4d\u4ef7\u503c\u66f4\u5927\u7684\u7269\u54c1\u603b\u662f\u66f4\u4f18\u9009\u62e9\uff0c\u8fd9\u8bf4\u660e\u8d2a\u5fc3\u7b56\u7565\u662f\u6709\u6548\u7684\u3002

    \u5982\u56fe 15-6 \u6240\u793a\uff0c\u5982\u679c\u5c06\u7269\u54c1\u91cd\u91cf\u548c\u7269\u54c1\u5355\u4f4d\u4ef7\u503c\u5206\u522b\u770b\u4f5c\u4e00\u5f20\u4e8c\u7ef4\u56fe\u8868\u7684\u6a2a\u8f74\u548c\u7eb5\u8f74\uff0c\u5219\u5206\u6570\u80cc\u5305\u95ee\u9898\u53ef\u8f6c\u5316\u4e3a\u201c\u6c42\u5728\u6709\u9650\u6a2a\u8f74\u533a\u95f4\u4e0b\u56f4\u6210\u7684\u6700\u5927\u9762\u79ef\u201d\u3002\u8fd9\u4e2a\u7c7b\u6bd4\u53ef\u4ee5\u5e2e\u52a9\u6211\u4eec\u4ece\u51e0\u4f55\u89d2\u5ea6\u7406\u89e3\u8d2a\u5fc3\u7b56\u7565\u7684\u6709\u6548\u6027\u3002

    \u56fe 15-6 \u00a0 \u5206\u6570\u80cc\u5305\u95ee\u9898\u7684\u51e0\u4f55\u8868\u793a

    "},{"location":"chapter_greedy/greedy_algorithm/","title":"15.1 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5","text":"

    \u300c\u8d2a\u5fc3\u7b97\u6cd5 greedy algorithm\u300d\u662f\u4e00\u79cd\u5e38\u89c1\u7684\u89e3\u51b3\u4f18\u5316\u95ee\u9898\u7684\u7b97\u6cd5\uff0c\u5176\u57fa\u672c\u601d\u60f3\u662f\u5728\u95ee\u9898\u7684\u6bcf\u4e2a\u51b3\u7b56\u9636\u6bb5\uff0c\u90fd\u9009\u62e9\u5f53\u524d\u770b\u8d77\u6765\u6700\u4f18\u7684\u9009\u62e9\uff0c\u5373\u8d2a\u5fc3\u5730\u505a\u51fa\u5c40\u90e8\u6700\u4f18\u7684\u51b3\u7b56\uff0c\u4ee5\u671f\u83b7\u5f97\u5168\u5c40\u6700\u4f18\u89e3\u3002\u8d2a\u5fc3\u7b97\u6cd5\u7b80\u6d01\u4e14\u9ad8\u6548\uff0c\u5728\u8bb8\u591a\u5b9e\u9645\u95ee\u9898\u4e2d\u6709\u7740\u5e7f\u6cdb\u7684\u5e94\u7528\u3002

    \u8d2a\u5fc3\u7b97\u6cd5\u548c\u52a8\u6001\u89c4\u5212\u90fd\u5e38\u7528\u4e8e\u89e3\u51b3\u4f18\u5316\u95ee\u9898\u3002\u5b83\u4eec\u4e4b\u95f4\u5b58\u5728\u4e00\u4e9b\u76f8\u4f3c\u4e4b\u5904\uff0c\u6bd4\u5982\u90fd\u4f9d\u8d56\u6700\u4f18\u5b50\u7ed3\u6784\u6027\u8d28\uff0c\u4f46\u5de5\u4f5c\u539f\u7406\u4e0d\u540c\u3002

    • \u52a8\u6001\u89c4\u5212\u4f1a\u6839\u636e\u4e4b\u524d\u9636\u6bb5\u7684\u6240\u6709\u51b3\u7b56\u6765\u8003\u8651\u5f53\u524d\u51b3\u7b56\uff0c\u5e76\u4f7f\u7528\u8fc7\u53bb\u5b50\u95ee\u9898\u7684\u89e3\u6765\u6784\u5efa\u5f53\u524d\u5b50\u95ee\u9898\u7684\u89e3\u3002
    • \u8d2a\u5fc3\u7b97\u6cd5\u4e0d\u4f1a\u8003\u8651\u8fc7\u53bb\u7684\u51b3\u7b56\uff0c\u800c\u662f\u4e00\u8def\u5411\u524d\u5730\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u4e0d\u65ad\u7f29\u5c0f\u95ee\u9898\u8303\u56f4\uff0c\u76f4\u81f3\u95ee\u9898\u88ab\u89e3\u51b3\u3002

    \u6211\u4eec\u5148\u901a\u8fc7\u4f8b\u9898\u201c\u96f6\u94b1\u5151\u6362\u201d\u4e86\u89e3\u8d2a\u5fc3\u7b97\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u3002\u8fd9\u9053\u9898\u5df2\u7ecf\u5728\u201c\u5b8c\u5168\u80cc\u5305\u95ee\u9898\u201d\u7ae0\u8282\u4e2d\u4ecb\u7ecd\u8fc7\uff0c\u76f8\u4fe1\u4f60\u5bf9\u5b83\u5e76\u4e0d\u964c\u751f\u3002

    Question

    \u7ed9\u5b9a \\(n\\) \u79cd\u786c\u5e01\uff0c\u7b2c \\(i\\) \u79cd\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\u80fd\u591f\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u7684\u6700\u5c11\u786c\u5e01\u6570\u91cf\u3002\u5982\u679c\u65e0\u6cd5\u51d1\u51fa\u76ee\u6807\u91d1\u989d\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002

    \u672c\u9898\u91c7\u53d6\u7684\u8d2a\u5fc3\u7b56\u7565\u5982\u56fe 15-1 \u6240\u793a\u3002\u7ed9\u5b9a\u76ee\u6807\u91d1\u989d\uff0c\u6211\u4eec\u8d2a\u5fc3\u5730\u9009\u62e9\u4e0d\u5927\u4e8e\u4e14\u6700\u63a5\u8fd1\u5b83\u7684\u786c\u5e01\uff0c\u4e0d\u65ad\u5faa\u73af\u8be5\u6b65\u9aa4\uff0c\u76f4\u81f3\u51d1\u51fa\u76ee\u6807\u91d1\u989d\u4e3a\u6b62\u3002

    \u56fe 15-1 \u00a0 \u96f6\u94b1\u5151\u6362\u7684\u8d2a\u5fc3\u7b56\u7565

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig coin_change_greedy.py
    def coin_change_greedy(coins: list[int], amt: int) -> int:\n    \"\"\"\u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3\"\"\"\n    # \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    i = len(coins) - 1\n    count = 0\n    # \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while amt > 0:\n        # \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while i > 0 and coins[i] > amt:\n            i -= 1\n        # \u9009\u62e9 coins[i]\n        amt -= coins[i]\n        count += 1\n    # \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return count if amt == 0 else -1\n
    coin_change_greedy.cpp
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint coinChangeGreedy(vector<int> &coins, int amt) {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    int i = coins.size() - 1;\n    int count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.java
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint coinChangeGreedy(int[] coins, int amt) {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    int i = coins.length - 1;\n    int count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.cs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint CoinChangeGreedy(int[] coins, int amt) {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    int i = coins.Length - 1;\n    int count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.go
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfunc coinChangeGreedy(coins []int, amt int) int {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    i := len(coins) - 1\n    count := 0\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    for amt > 0 {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        for i > 0 && coins[i] > amt {\n            i--\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i]\n        count++\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    if amt != 0 {\n        return -1\n    }\n    return count\n}\n
    coin_change_greedy.swift
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfunc coinChangeGreedy(coins: [Int], amt: Int) -> Int {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    var i = coins.count - 1\n    var count = 0\n    var amt = amt\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while amt > 0 {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while i > 0 && coins[i] > amt {\n            i -= 1\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i]\n        count += 1\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1\n}\n
    coin_change_greedy.js
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfunction coinChangeGreedy(coins, amt) {\n    // \u5047\u8bbe coins \u6570\u7ec4\u6709\u5e8f\n    let i = coins.length - 1;\n    let count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt === 0 ? count : -1;\n}\n
    coin_change_greedy.ts
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfunction coinChangeGreedy(coins: number[], amt: number): number {\n    // \u5047\u8bbe coins \u6570\u7ec4\u6709\u5e8f\n    let i = coins.length - 1;\n    let count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt === 0 ? count : -1;\n}\n
    coin_change_greedy.dart
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint coinChangeGreedy(List<int> coins, int amt) {\n  // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n  int i = coins.length - 1;\n  int count = 0;\n  // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n  while (amt > 0) {\n    // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n    while (i > 0 && coins[i] > amt) {\n      i--;\n    }\n    // \u9009\u62e9 coins[i]\n    amt -= coins[i];\n    count++;\n  }\n  // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n  return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.rs
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfn coin_change_greedy(coins: &[i32], mut amt: i32) -> i32 {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    let mut i = coins.len() - 1;\n    let mut count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while amt > 0 {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while i > 0 && coins[i] > amt {\n            i -= 1;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count += 1;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    if amt == 0 {\n        count\n    } else {\n        -1\n    }\n}\n
    coin_change_greedy.c
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nint coinChangeGreedy(int *coins, int size, int amt) {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    int i = size - 1;\n    int count = 0;\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (amt > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > amt) {\n            i--;\n        }\n        // \u9009\u62e9 coins[i]\n        amt -= coins[i];\n        count++;\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return amt == 0 ? count : -1;\n}\n
    coin_change_greedy.kt
    /* \u96f6\u94b1\u5151\u6362\uff1a\u8d2a\u5fc3 */\nfun coinChangeGreedy(coins: IntArray, amt: Int): Int {\n    // \u5047\u8bbe coins \u5217\u8868\u6709\u5e8f\n    var am = amt\n    var i = coins.size - 1\n    var count = 0\n    // \u5faa\u73af\u8fdb\u884c\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u5230\u65e0\u5269\u4f59\u91d1\u989d\n    while (am > 0) {\n        // \u627e\u5230\u5c0f\u4e8e\u4e14\u6700\u63a5\u8fd1\u5269\u4f59\u91d1\u989d\u7684\u786c\u5e01\n        while (i > 0 && coins[i] > am) {\n            i--\n        }\n        // \u9009\u62e9 coins[i]\n        am -= coins[i]\n        count++\n    }\n    // \u82e5\u672a\u627e\u5230\u53ef\u884c\u65b9\u6848\uff0c\u5219\u8fd4\u56de -1\n    return if (am == 0) count else -1\n}\n
    coin_change_greedy.rb
    [class]{}-[func]{coin_change_greedy}\n
    coin_change_greedy.zig
    [class]{}-[func]{coinChangeGreedy}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u4f60\u53ef\u80fd\u4f1a\u4e0d\u7531\u5730\u53d1\u51fa\u611f\u53f9\uff1aSo clean \uff01\u8d2a\u5fc3\u7b97\u6cd5\u4ec5\u7528\u7ea6\u5341\u884c\u4ee3\u7801\u5c31\u89e3\u51b3\u4e86\u96f6\u94b1\u5151\u6362\u95ee\u9898\u3002

    "},{"location":"chapter_greedy/greedy_algorithm/#1511","title":"15.1.1 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u7684\u4f18\u70b9\u4e0e\u5c40\u9650\u6027","text":"

    \u8d2a\u5fc3\u7b97\u6cd5\u4e0d\u4ec5\u64cd\u4f5c\u76f4\u63a5\u3001\u5b9e\u73b0\u7b80\u5355\uff0c\u800c\u4e14\u901a\u5e38\u6548\u7387\u4e5f\u5f88\u9ad8\u3002\u5728\u4ee5\u4e0a\u4ee3\u7801\u4e2d\uff0c\u8bb0\u786c\u5e01\u6700\u5c0f\u9762\u503c\u4e3a \\(\\min(coins)\\) \uff0c\u5219\u8d2a\u5fc3\u9009\u62e9\u6700\u591a\u5faa\u73af \\(amt / \\min(coins)\\) \u6b21\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(amt / \\min(coins))\\) \u3002\u8fd9\u6bd4\u52a8\u6001\u89c4\u5212\u89e3\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6 \\(O(n \\times amt)\\) \u5c0f\u4e86\u4e00\u4e2a\u6570\u91cf\u7ea7\u3002

    \u7136\u800c\uff0c\u5bf9\u4e8e\u67d0\u4e9b\u786c\u5e01\u9762\u503c\u7ec4\u5408\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u5e76\u4e0d\u80fd\u627e\u5230\u6700\u4f18\u89e3\u3002\u56fe 15-2 \u7ed9\u51fa\u4e86\u4e24\u4e2a\u793a\u4f8b\u3002

    • \u6b63\u4f8b \\(coins = [1, 5, 10, 20, 50, 100]\\)\uff1a\u5728\u8be5\u786c\u5e01\u7ec4\u5408\u4e0b\uff0c\u7ed9\u5b9a\u4efb\u610f \\(amt\\) \uff0c\u8d2a\u5fc3\u7b97\u6cd5\u90fd\u53ef\u4ee5\u627e\u5230\u6700\u4f18\u89e3\u3002
    • \u53cd\u4f8b \\(coins = [1, 20, 50]\\)\uff1a\u5047\u8bbe \\(amt = 60\\) \uff0c\u8d2a\u5fc3\u7b97\u6cd5\u53ea\u80fd\u627e\u5230 \\(50 + 1 \\times 10\\) \u7684\u5151\u6362\u7ec4\u5408\uff0c\u5171\u8ba1 \\(11\\) \u679a\u786c\u5e01\uff0c\u4f46\u52a8\u6001\u89c4\u5212\u53ef\u4ee5\u627e\u5230\u6700\u4f18\u89e3 \\(20 + 20 + 20\\) \uff0c\u4ec5\u9700 \\(3\\) \u679a\u786c\u5e01\u3002
    • \u53cd\u4f8b \\(coins = [1, 49, 50]\\)\uff1a\u5047\u8bbe \\(amt = 98\\) \uff0c\u8d2a\u5fc3\u7b97\u6cd5\u53ea\u80fd\u627e\u5230 \\(50 + 1 \\times 48\\) \u7684\u5151\u6362\u7ec4\u5408\uff0c\u5171\u8ba1 \\(49\\) \u679a\u786c\u5e01\uff0c\u4f46\u52a8\u6001\u89c4\u5212\u53ef\u4ee5\u627e\u5230\u6700\u4f18\u89e3 \\(49 + 49\\) \uff0c\u4ec5\u9700 \\(2\\) \u679a\u786c\u5e01\u3002

    \u56fe 15-2 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u65e0\u6cd5\u627e\u51fa\u6700\u4f18\u89e3\u7684\u793a\u4f8b

    \u4e5f\u5c31\u662f\u8bf4\uff0c\u5bf9\u4e8e\u96f6\u94b1\u5151\u6362\u95ee\u9898\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u65e0\u6cd5\u4fdd\u8bc1\u627e\u5230\u5168\u5c40\u6700\u4f18\u89e3\uff0c\u5e76\u4e14\u6709\u53ef\u80fd\u627e\u5230\u975e\u5e38\u5dee\u7684\u89e3\u3002\u5b83\u66f4\u9002\u5408\u7528\u52a8\u6001\u89c4\u5212\u89e3\u51b3\u3002

    \u4e00\u822c\u60c5\u51b5\u4e0b\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u7684\u9002\u7528\u60c5\u51b5\u5206\u4ee5\u4e0b\u4e24\u79cd\u3002

    1. \u53ef\u4ee5\u4fdd\u8bc1\u627e\u5230\u6700\u4f18\u89e3\uff1a\u8d2a\u5fc3\u7b97\u6cd5\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\u5f80\u5f80\u662f\u6700\u4f18\u9009\u62e9\uff0c\u56e0\u4e3a\u5b83\u5f80\u5f80\u6bd4\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\u66f4\u9ad8\u6548\u3002
    2. \u53ef\u4ee5\u627e\u5230\u8fd1\u4f3c\u6700\u4f18\u89e3\uff1a\u8d2a\u5fc3\u7b97\u6cd5\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\u4e5f\u662f\u53ef\u7528\u7684\u3002\u5bf9\u4e8e\u5f88\u591a\u590d\u6742\u95ee\u9898\u6765\u8bf4\uff0c\u5bfb\u627e\u5168\u5c40\u6700\u4f18\u89e3\u975e\u5e38\u56f0\u96be\uff0c\u80fd\u4ee5\u8f83\u9ad8\u6548\u7387\u627e\u5230\u6b21\u4f18\u89e3\u4e5f\u662f\u975e\u5e38\u4e0d\u9519\u7684\u3002
    "},{"location":"chapter_greedy/greedy_algorithm/#1512","title":"15.1.2 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u7279\u6027","text":"

    \u90a3\u4e48\u95ee\u9898\u6765\u4e86\uff0c\u4ec0\u4e48\u6837\u7684\u95ee\u9898\u9002\u5408\u7528\u8d2a\u5fc3\u7b97\u6cd5\u6c42\u89e3\u5462\uff1f\u6216\u8005\u8bf4\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u5728\u4ec0\u4e48\u60c5\u51b5\u4e0b\u53ef\u4ee5\u4fdd\u8bc1\u627e\u5230\u6700\u4f18\u89e3\uff1f

    \u76f8\u8f83\u4e8e\u52a8\u6001\u89c4\u5212\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u7684\u4f7f\u7528\u6761\u4ef6\u66f4\u52a0\u82db\u523b\uff0c\u5176\u4e3b\u8981\u5173\u6ce8\u95ee\u9898\u7684\u4e24\u4e2a\u6027\u8d28\u3002

    • \u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\uff1a\u53ea\u6709\u5f53\u5c40\u90e8\u6700\u4f18\u9009\u62e9\u59cb\u7ec8\u53ef\u4ee5\u5bfc\u81f4\u5168\u5c40\u6700\u4f18\u89e3\u65f6\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u624d\u80fd\u4fdd\u8bc1\u5f97\u5230\u6700\u4f18\u89e3\u3002
    • \u6700\u4f18\u5b50\u7ed3\u6784\uff1a\u539f\u95ee\u9898\u7684\u6700\u4f18\u89e3\u5305\u542b\u5b50\u95ee\u9898\u7684\u6700\u4f18\u89e3\u3002

    \u6700\u4f18\u5b50\u7ed3\u6784\u5df2\u7ecf\u5728\u201c\u52a8\u6001\u89c4\u5212\u201d\u7ae0\u8282\u4e2d\u4ecb\u7ecd\u8fc7\uff0c\u8fd9\u91cc\u4e0d\u518d\u8d58\u8ff0\u3002\u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u4e00\u4e9b\u95ee\u9898\u7684\u6700\u4f18\u5b50\u7ed3\u6784\u5e76\u4e0d\u660e\u663e\uff0c\u4f46\u4ecd\u7136\u53ef\u4f7f\u7528\u8d2a\u5fc3\u7b97\u6cd5\u89e3\u51b3\u3002

    \u6211\u4eec\u4e3b\u8981\u63a2\u7a76\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u7684\u5224\u65ad\u65b9\u6cd5\u3002\u867d\u7136\u5b83\u7684\u63cf\u8ff0\u770b\u4e0a\u53bb\u6bd4\u8f83\u7b80\u5355\uff0c\u4f46\u5b9e\u9645\u4e0a\u5bf9\u4e8e\u8bb8\u591a\u95ee\u9898\uff0c\u8bc1\u660e\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u5e76\u975e\u6613\u4e8b\u3002

    \u4f8b\u5982\u96f6\u94b1\u5151\u6362\u95ee\u9898\uff0c\u6211\u4eec\u867d\u7136\u80fd\u591f\u5bb9\u6613\u5730\u4e3e\u51fa\u53cd\u4f8b\uff0c\u5bf9\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u8fdb\u884c\u8bc1\u4f2a\uff0c\u4f46\u8bc1\u5b9e\u7684\u96be\u5ea6\u8f83\u5927\u3002\u5982\u679c\u95ee\uff1a\u6ee1\u8db3\u4ec0\u4e48\u6761\u4ef6\u7684\u786c\u5e01\u7ec4\u5408\u53ef\u4ee5\u4f7f\u7528\u8d2a\u5fc3\u7b97\u6cd5\u6c42\u89e3\uff1f\u6211\u4eec\u5f80\u5f80\u53ea\u80fd\u51ed\u501f\u76f4\u89c9\u6216\u4e3e\u4f8b\u5b50\u6765\u7ed9\u51fa\u4e00\u4e2a\u6a21\u68f1\u4e24\u53ef\u7684\u7b54\u6848\uff0c\u800c\u96be\u4ee5\u7ed9\u51fa\u4e25\u8c28\u7684\u6570\u5b66\u8bc1\u660e\u3002

    Quote

    \u6709\u4e00\u7bc7\u8bba\u6587\u7ed9\u51fa\u4e86\u4e00\u4e2a \\(O(n^3)\\) \u65f6\u95f4\u590d\u6742\u5ea6\u7684\u7b97\u6cd5\uff0c\u7528\u4e8e\u5224\u65ad\u4e00\u4e2a\u786c\u5e01\u7ec4\u5408\u80fd\u5426\u4f7f\u7528\u8d2a\u5fc3\u7b97\u6cd5\u627e\u51fa\u4efb\u610f\u91d1\u989d\u7684\u6700\u4f18\u89e3\u3002

    Pearson, D. A polynomial-time algorithm for the change-making problem[J]. Operations Research Letters, 2005, 33(3): 231-234.

    "},{"location":"chapter_greedy/greedy_algorithm/#1513","title":"15.1.3 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u89e3\u9898\u6b65\u9aa4","text":"

    \u8d2a\u5fc3\u95ee\u9898\u7684\u89e3\u51b3\u6d41\u7a0b\u5927\u4f53\u53ef\u5206\u4e3a\u4ee5\u4e0b\u4e09\u6b65\u3002

    1. \u95ee\u9898\u5206\u6790\uff1a\u68b3\u7406\u4e0e\u7406\u89e3\u95ee\u9898\u7279\u6027\uff0c\u5305\u62ec\u72b6\u6001\u5b9a\u4e49\u3001\u4f18\u5316\u76ee\u6807\u548c\u7ea6\u675f\u6761\u4ef6\u7b49\u3002\u8fd9\u4e00\u6b65\u5728\u56de\u6eaf\u548c\u52a8\u6001\u89c4\u5212\u4e2d\u90fd\u6709\u6d89\u53ca\u3002
    2. \u786e\u5b9a\u8d2a\u5fc3\u7b56\u7565\uff1a\u786e\u5b9a\u5982\u4f55\u5728\u6bcf\u4e00\u6b65\u4e2d\u505a\u51fa\u8d2a\u5fc3\u9009\u62e9\u3002\u8fd9\u4e2a\u7b56\u7565\u80fd\u591f\u5728\u6bcf\u4e00\u6b65\u51cf\u5c0f\u95ee\u9898\u7684\u89c4\u6a21\uff0c\u5e76\u6700\u7ec8\u89e3\u51b3\u6574\u4e2a\u95ee\u9898\u3002
    3. \u6b63\u786e\u6027\u8bc1\u660e\uff1a\u901a\u5e38\u9700\u8981\u8bc1\u660e\u95ee\u9898\u5177\u6709\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u548c\u6700\u4f18\u5b50\u7ed3\u6784\u3002\u8fd9\u4e2a\u6b65\u9aa4\u53ef\u80fd\u9700\u8981\u7528\u5230\u6570\u5b66\u8bc1\u660e\uff0c\u4f8b\u5982\u5f52\u7eb3\u6cd5\u6216\u53cd\u8bc1\u6cd5\u7b49\u3002

    \u786e\u5b9a\u8d2a\u5fc3\u7b56\u7565\u662f\u6c42\u89e3\u95ee\u9898\u7684\u6838\u5fc3\u6b65\u9aa4\uff0c\u4f46\u5b9e\u65bd\u8d77\u6765\u53ef\u80fd\u5e76\u4e0d\u5bb9\u6613\uff0c\u4e3b\u8981\u6709\u4ee5\u4e0b\u539f\u56e0\u3002

    • \u4e0d\u540c\u95ee\u9898\u7684\u8d2a\u5fc3\u7b56\u7565\u7684\u5dee\u5f02\u8f83\u5927\u3002\u5bf9\u4e8e\u8bb8\u591a\u95ee\u9898\u6765\u8bf4\uff0c\u8d2a\u5fc3\u7b56\u7565\u6bd4\u8f83\u6d45\u663e\uff0c\u6211\u4eec\u901a\u8fc7\u4e00\u4e9b\u5927\u6982\u7684\u601d\u8003\u4e0e\u5c1d\u8bd5\u5c31\u80fd\u5f97\u51fa\u3002\u800c\u5bf9\u4e8e\u4e00\u4e9b\u590d\u6742\u95ee\u9898\uff0c\u8d2a\u5fc3\u7b56\u7565\u53ef\u80fd\u975e\u5e38\u9690\u853d\uff0c\u8fd9\u79cd\u60c5\u51b5\u5c31\u975e\u5e38\u8003\u9a8c\u4e2a\u4eba\u7684\u89e3\u9898\u7ecf\u9a8c\u4e0e\u7b97\u6cd5\u80fd\u529b\u4e86\u3002
    • \u67d0\u4e9b\u8d2a\u5fc3\u7b56\u7565\u5177\u6709\u8f83\u5f3a\u7684\u8ff7\u60d1\u6027\u3002\u5f53\u6211\u4eec\u6ee1\u6000\u4fe1\u5fc3\u8bbe\u8ba1\u597d\u8d2a\u5fc3\u7b56\u7565\uff0c\u5199\u51fa\u89e3\u9898\u4ee3\u7801\u5e76\u63d0\u4ea4\u8fd0\u884c\uff0c\u5f88\u53ef\u80fd\u53d1\u73b0\u90e8\u5206\u6d4b\u8bd5\u6837\u4f8b\u65e0\u6cd5\u901a\u8fc7\u3002\u8fd9\u662f\u56e0\u4e3a\u8bbe\u8ba1\u7684\u8d2a\u5fc3\u7b56\u7565\u53ea\u662f\u201c\u90e8\u5206\u6b63\u786e\u201d\u7684\uff0c\u4e0a\u6587\u4ecb\u7ecd\u7684\u96f6\u94b1\u5151\u6362\u5c31\u662f\u4e00\u4e2a\u5178\u578b\u6848\u4f8b\u3002

    \u4e3a\u4e86\u4fdd\u8bc1\u6b63\u786e\u6027\uff0c\u6211\u4eec\u5e94\u8be5\u5bf9\u8d2a\u5fc3\u7b56\u7565\u8fdb\u884c\u4e25\u8c28\u7684\u6570\u5b66\u8bc1\u660e\uff0c\u901a\u5e38\u9700\u8981\u7528\u5230\u53cd\u8bc1\u6cd5\u6216\u6570\u5b66\u5f52\u7eb3\u6cd5\u3002

    \u7136\u800c\uff0c\u6b63\u786e\u6027\u8bc1\u660e\u4e5f\u5f88\u53ef\u80fd\u4e0d\u662f\u4e00\u4ef6\u6613\u4e8b\u3002\u5982\u82e5\u6ca1\u6709\u5934\u7eea\uff0c\u6211\u4eec\u901a\u5e38\u4f1a\u9009\u62e9\u9762\u5411\u6d4b\u8bd5\u7528\u4f8b\u8fdb\u884c\u4ee3\u7801\u8c03\u8bd5\uff0c\u4e00\u6b65\u6b65\u4fee\u6539\u4e0e\u9a8c\u8bc1\u8d2a\u5fc3\u7b56\u7565\u3002

    "},{"location":"chapter_greedy/greedy_algorithm/#1514","title":"15.1.4 \u00a0 \u8d2a\u5fc3\u7b97\u6cd5\u5178\u578b\u4f8b\u9898","text":"

    \u8d2a\u5fc3\u7b97\u6cd5\u5e38\u5e38\u5e94\u7528\u5728\u6ee1\u8db3\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u548c\u6700\u4f18\u5b50\u7ed3\u6784\u7684\u4f18\u5316\u95ee\u9898\u4e2d\uff0c\u4ee5\u4e0b\u5217\u4e3e\u4e86\u4e00\u4e9b\u5178\u578b\u7684\u8d2a\u5fc3\u7b97\u6cd5\u95ee\u9898\u3002

    • \u786c\u5e01\u627e\u96f6\u95ee\u9898\uff1a\u5728\u67d0\u4e9b\u786c\u5e01\u7ec4\u5408\u4e0b\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u603b\u662f\u53ef\u4ee5\u5f97\u5230\u6700\u4f18\u89e3\u3002
    • \u533a\u95f4\u8c03\u5ea6\u95ee\u9898\uff1a\u5047\u8bbe\u4f60\u6709\u4e00\u4e9b\u4efb\u52a1\uff0c\u6bcf\u4e2a\u4efb\u52a1\u5728\u4e00\u6bb5\u65f6\u95f4\u5185\u8fdb\u884c\uff0c\u4f60\u7684\u76ee\u6807\u662f\u5b8c\u6210\u5c3d\u53ef\u80fd\u591a\u7684\u4efb\u52a1\u3002\u5982\u679c\u6bcf\u6b21\u90fd\u9009\u62e9\u7ed3\u675f\u65f6\u95f4\u6700\u65e9\u7684\u4efb\u52a1\uff0c\u90a3\u4e48\u8d2a\u5fc3\u7b97\u6cd5\u5c31\u53ef\u4ee5\u5f97\u5230\u6700\u4f18\u89e3\u3002
    • \u5206\u6570\u80cc\u5305\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u7ec4\u7269\u54c1\u548c\u4e00\u4e2a\u8f7d\u91cd\u91cf\uff0c\u4f60\u7684\u76ee\u6807\u662f\u9009\u62e9\u4e00\u7ec4\u7269\u54c1\uff0c\u4f7f\u5f97\u603b\u91cd\u91cf\u4e0d\u8d85\u8fc7\u8f7d\u91cd\u91cf\uff0c\u4e14\u603b\u4ef7\u503c\u6700\u5927\u3002\u5982\u679c\u6bcf\u6b21\u90fd\u9009\u62e9\u6027\u4ef7\u6bd4\u6700\u9ad8\uff08\u4ef7\u503c / \u91cd\u91cf\uff09\u7684\u7269\u54c1\uff0c\u90a3\u4e48\u8d2a\u5fc3\u7b97\u6cd5\u5728\u4e00\u4e9b\u60c5\u51b5\u4e0b\u53ef\u4ee5\u5f97\u5230\u6700\u4f18\u89e3\u3002
    • \u80a1\u7968\u4e70\u5356\u95ee\u9898\uff1a\u7ed9\u5b9a\u4e00\u7ec4\u80a1\u7968\u7684\u5386\u53f2\u4ef7\u683c\uff0c\u4f60\u53ef\u4ee5\u8fdb\u884c\u591a\u6b21\u4e70\u5356\uff0c\u4f46\u5982\u679c\u4f60\u5df2\u7ecf\u6301\u6709\u80a1\u7968\uff0c\u90a3\u4e48\u5728\u5356\u51fa\u4e4b\u524d\u4e0d\u80fd\u518d\u4e70\uff0c\u76ee\u6807\u662f\u83b7\u53d6\u6700\u5927\u5229\u6da6\u3002
    • \u970d\u592b\u66fc\u7f16\u7801\uff1a\u970d\u592b\u66fc\u7f16\u7801\u662f\u4e00\u79cd\u7528\u4e8e\u65e0\u635f\u6570\u636e\u538b\u7f29\u7684\u8d2a\u5fc3\u7b97\u6cd5\u3002\u901a\u8fc7\u6784\u5efa\u970d\u592b\u66fc\u6811\uff0c\u6bcf\u6b21\u9009\u62e9\u51fa\u73b0\u9891\u7387\u6700\u4f4e\u7684\u4e24\u4e2a\u8282\u70b9\u5408\u5e76\uff0c\u6700\u540e\u5f97\u5230\u7684\u970d\u592b\u66fc\u6811\u7684\u5e26\u6743\u8def\u5f84\u957f\u5ea6\uff08\u7f16\u7801\u957f\u5ea6\uff09\u6700\u5c0f\u3002
    • Dijkstra \u7b97\u6cd5\uff1a\u5b83\u662f\u4e00\u79cd\u89e3\u51b3\u7ed9\u5b9a\u6e90\u9876\u70b9\u5230\u5176\u4f59\u5404\u9876\u70b9\u7684\u6700\u77ed\u8def\u5f84\u95ee\u9898\u7684\u8d2a\u5fc3\u7b97\u6cd5\u3002
    "},{"location":"chapter_greedy/max_capacity_problem/","title":"15.3 \u00a0 \u6700\u5927\u5bb9\u91cf\u95ee\u9898","text":"

    Question

    \u8f93\u5165\u4e00\u4e2a\u6570\u7ec4 \\(ht\\) \uff0c\u5176\u4e2d\u7684\u6bcf\u4e2a\u5143\u7d20\u4ee3\u8868\u4e00\u4e2a\u5782\u76f4\u9694\u677f\u7684\u9ad8\u5ea6\u3002\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u4e24\u4e2a\u9694\u677f\uff0c\u4ee5\u53ca\u5b83\u4eec\u4e4b\u95f4\u7684\u7a7a\u95f4\u53ef\u4ee5\u7ec4\u6210\u4e00\u4e2a\u5bb9\u5668\u3002

    \u5bb9\u5668\u7684\u5bb9\u91cf\u7b49\u4e8e\u9ad8\u5ea6\u548c\u5bbd\u5ea6\u7684\u4e58\u79ef\uff08\u9762\u79ef\uff09\uff0c\u5176\u4e2d\u9ad8\u5ea6\u7531\u8f83\u77ed\u7684\u9694\u677f\u51b3\u5b9a\uff0c\u5bbd\u5ea6\u662f\u4e24\u4e2a\u9694\u677f\u7684\u6570\u7ec4\u7d22\u5f15\u4e4b\u5dee\u3002

    \u8bf7\u5728\u6570\u7ec4\u4e2d\u9009\u62e9\u4e24\u4e2a\u9694\u677f\uff0c\u4f7f\u5f97\u7ec4\u6210\u7684\u5bb9\u5668\u7684\u5bb9\u91cf\u6700\u5927\uff0c\u8fd4\u56de\u6700\u5927\u5bb9\u91cf\u3002\u793a\u4f8b\u5982\u56fe 15-7 \u6240\u793a\u3002

    \u56fe 15-7 \u00a0 \u6700\u5927\u5bb9\u91cf\u95ee\u9898\u7684\u793a\u4f8b\u6570\u636e

    \u5bb9\u5668\u7531\u4efb\u610f\u4e24\u4e2a\u9694\u677f\u56f4\u6210\uff0c\u56e0\u6b64\u672c\u9898\u7684\u72b6\u6001\u4e3a\u4e24\u4e2a\u9694\u677f\u7684\u7d22\u5f15\uff0c\u8bb0\u4e3a \\([i, j]\\) \u3002

    \u6839\u636e\u9898\u610f\uff0c\u5bb9\u91cf\u7b49\u4e8e\u9ad8\u5ea6\u4e58\u4ee5\u5bbd\u5ea6\uff0c\u5176\u4e2d\u9ad8\u5ea6\u7531\u77ed\u677f\u51b3\u5b9a\uff0c\u5bbd\u5ea6\u662f\u4e24\u9694\u677f\u7684\u6570\u7ec4\u7d22\u5f15\u4e4b\u5dee\u3002\u8bbe\u5bb9\u91cf\u4e3a \\(cap[i, j]\\) \uff0c\u5219\u53ef\u5f97\u8ba1\u7b97\u516c\u5f0f\uff1a

    \\[ cap[i, j] = \\min(ht[i], ht[j]) \\times (j - i) \\]

    \u8bbe\u6570\u7ec4\u957f\u5ea6\u4e3a \\(n\\) \uff0c\u4e24\u4e2a\u9694\u677f\u7684\u7ec4\u5408\u6570\u91cf\uff08\u72b6\u6001\u603b\u6570\uff09\u4e3a \\(C_n^2 = \\frac{n(n - 1)}{2}\\) \u4e2a\u3002\u6700\u76f4\u63a5\u5730\uff0c\u6211\u4eec\u53ef\u4ee5\u7a77\u4e3e\u6240\u6709\u72b6\u6001\uff0c\u4ece\u800c\u6c42\u5f97\u6700\u5927\u5bb9\u91cf\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002

    "},{"location":"chapter_greedy/max_capacity_problem/#1","title":"1. \u00a0 \u8d2a\u5fc3\u7b56\u7565\u786e\u5b9a","text":"

    \u8fd9\u9053\u9898\u8fd8\u6709\u66f4\u9ad8\u6548\u7387\u7684\u89e3\u6cd5\u3002\u5982\u56fe 15-8 \u6240\u793a\uff0c\u73b0\u9009\u53d6\u4e00\u4e2a\u72b6\u6001 \\([i, j]\\) \uff0c\u5176\u6ee1\u8db3\u7d22\u5f15 \\(i < j\\) \u4e14\u9ad8\u5ea6 \\(ht[i] < ht[j]\\) \uff0c\u5373 \\(i\\) \u4e3a\u77ed\u677f\u3001\\(j\\) \u4e3a\u957f\u677f\u3002

    \u56fe 15-8 \u00a0 \u521d\u59cb\u72b6\u6001

    \u5982\u56fe 15-9 \u6240\u793a\uff0c\u82e5\u6b64\u65f6\u5c06\u957f\u677f \\(j\\) \u5411\u77ed\u677f \\(i\\) \u9760\u8fd1\uff0c\u5219\u5bb9\u91cf\u4e00\u5b9a\u53d8\u5c0f\u3002

    \u8fd9\u662f\u56e0\u4e3a\u5728\u79fb\u52a8\u957f\u677f \\(j\\) \u540e\uff0c\u5bbd\u5ea6 \\(j-i\\) \u80af\u5b9a\u53d8\u5c0f\uff1b\u800c\u9ad8\u5ea6\u7531\u77ed\u677f\u51b3\u5b9a\uff0c\u56e0\u6b64\u9ad8\u5ea6\u53ea\u53ef\u80fd\u4e0d\u53d8\uff08 \\(i\\) \u4ecd\u4e3a\u77ed\u677f\uff09\u6216\u53d8\u5c0f\uff08\u79fb\u52a8\u540e\u7684 \\(j\\) \u6210\u4e3a\u77ed\u677f\uff09\u3002

    \u56fe 15-9 \u00a0 \u5411\u5185\u79fb\u52a8\u957f\u677f\u540e\u7684\u72b6\u6001

    \u53cd\u5411\u601d\u8003\uff0c\u6211\u4eec\u53ea\u6709\u5411\u5185\u6536\u7f29\u77ed\u677f \\(i\\) \uff0c\u624d\u6709\u53ef\u80fd\u4f7f\u5bb9\u91cf\u53d8\u5927\u3002\u56e0\u4e3a\u867d\u7136\u5bbd\u5ea6\u4e00\u5b9a\u53d8\u5c0f\uff0c\u4f46\u9ad8\u5ea6\u53ef\u80fd\u4f1a\u53d8\u5927\uff08\u79fb\u52a8\u540e\u7684\u77ed\u677f \\(i\\) \u53ef\u80fd\u4f1a\u53d8\u957f\uff09\u3002\u4f8b\u5982\u5728\u56fe 15-10 \u4e2d\uff0c\u79fb\u52a8\u77ed\u677f\u540e\u9762\u79ef\u53d8\u5927\u3002

    \u56fe 15-10 \u00a0 \u5411\u5185\u79fb\u52a8\u77ed\u677f\u540e\u7684\u72b6\u6001

    \u7531\u6b64\u4fbf\u53ef\u63a8\u51fa\u672c\u9898\u7684\u8d2a\u5fc3\u7b56\u7565\uff1a\u521d\u59cb\u5316\u4e24\u6307\u9488\uff0c\u4f7f\u5176\u5206\u5217\u5bb9\u5668\u4e24\u7aef\uff0c\u6bcf\u8f6e\u5411\u5185\u6536\u7f29\u77ed\u677f\u5bf9\u5e94\u7684\u6307\u9488\uff0c\u76f4\u81f3\u4e24\u6307\u9488\u76f8\u9047\u3002

    \u56fe 15-11 \u5c55\u793a\u4e86\u8d2a\u5fc3\u7b56\u7565\u7684\u6267\u884c\u8fc7\u7a0b\u3002

    1. \u521d\u59cb\u72b6\u6001\u4e0b\uff0c\u6307\u9488 \\(i\\) \u548c \\(j\\) \u5206\u5217\u6570\u7ec4\u4e24\u7aef\u3002
    2. \u8ba1\u7b97\u5f53\u524d\u72b6\u6001\u7684\u5bb9\u91cf \\(cap[i, j]\\) \uff0c\u5e76\u66f4\u65b0\u6700\u5927\u5bb9\u91cf\u3002
    3. \u6bd4\u8f83\u677f \\(i\\) \u548c \u677f \\(j\\) \u7684\u9ad8\u5ea6\uff0c\u5e76\u5c06\u77ed\u677f\u5411\u5185\u79fb\u52a8\u4e00\u683c\u3002
    4. \u5faa\u73af\u6267\u884c\u7b2c 2. \u6b65\u548c\u7b2c 3. \u6b65\uff0c\u76f4\u81f3 \\(i\\) \u548c \\(j\\) \u76f8\u9047\u65f6\u7ed3\u675f\u3002
    <1><2><3><4><5><6><7><8><9>

    \u56fe 15-11 \u00a0 \u6700\u5927\u5bb9\u91cf\u95ee\u9898\u7684\u8d2a\u5fc3\u8fc7\u7a0b

    "},{"location":"chapter_greedy/max_capacity_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u4ee3\u7801\u5faa\u73af\u6700\u591a \\(n\\) \u8f6e\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002

    \u53d8\u91cf \\(i\\)\u3001\\(j\\)\u3001\\(res\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig max_capacity.py
    def max_capacity(ht: list[int]) -> int:\n    \"\"\"\u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3\"\"\"\n    # \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    i, j = 0, len(ht) - 1\n    # \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    res = 0\n    # \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while i < j:\n        # \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        # \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if ht[i] < ht[j]:\n            i += 1\n        else:\n            j -= 1\n    return res\n
    max_capacity.cpp
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint maxCapacity(vector<int> &ht) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    int i = 0, j = ht.size() - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    int res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        int cap = min(ht[i], ht[j]) * (j - i);\n        res = max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n
    max_capacity.java
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint maxCapacity(int[] ht) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    int i = 0, j = ht.length - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    int res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        int cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n
    max_capacity.cs
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint MaxCapacity(int[] ht) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    int i = 0, j = ht.Length - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    int res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        int cap = Math.Min(ht[i], ht[j]) * (j - i);\n        res = Math.Max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n
    max_capacity.go
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfunc maxCapacity(ht []int) int {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    i, j := 0, len(ht)-1\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    res := 0\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    for i < j {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)\n        res = int(math.Max(float64(res), float64(capacity)))\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if ht[i] < ht[j] {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n
    max_capacity.swift
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfunc maxCapacity(ht: [Int]) -> Int {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    var i = ht.startIndex, j = ht.endIndex - 1\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    var res = 0\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while i < j {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        let cap = min(ht[i], ht[j]) * (j - i)\n        res = max(res, cap)\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if ht[i] < ht[j] {\n            i += 1\n        } else {\n            j -= 1\n        }\n    }\n    return res\n}\n
    max_capacity.js
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfunction maxCapacity(ht) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    let i = 0,\n        j = ht.length - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    let res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        const cap = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n
    max_capacity.ts
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfunction maxCapacity(ht: number[]): number {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    let i = 0,\n        j = ht.length - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    let res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        const cap: number = Math.min(ht[i], ht[j]) * (j - i);\n        res = Math.max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    return res;\n}\n
    max_capacity.dart
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint maxCapacity(List<int> ht) {\n  // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n  int i = 0, j = ht.length - 1;\n  // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n  int res = 0;\n  // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n  while (i < j) {\n    // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n    int cap = min(ht[i], ht[j]) * (j - i);\n    res = max(res, cap);\n    // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n    if (ht[i] < ht[j]) {\n      i++;\n    } else {\n      j--;\n    }\n  }\n  return res;\n}\n
    max_capacity.rs
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfn max_capacity(ht: &[i32]) -> i32 {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    let mut i = 0;\n    let mut j = ht.len() - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    let mut res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while i < j {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;\n        res = std::cmp::max(res, cap);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if ht[i] < ht[j] {\n            i += 1;\n        } else {\n            j -= 1;\n        }\n    }\n    res\n}\n
    max_capacity.c
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nint maxCapacity(int ht[], int htLength) {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    int i = 0;\n    int j = htLength - 1;\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    int res = 0;\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        int capacity = myMin(ht[i], ht[j]) * (j - i);\n        res = myMax(res, capacity);\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++;\n        } else {\n            j--;\n        }\n    }\n    return res;\n}\n
    max_capacity.kt
    /* \u6700\u5927\u5bb9\u91cf\uff1a\u8d2a\u5fc3 */\nfun maxCapacity(ht: IntArray): Int {\n    // \u521d\u59cb\u5316 i, j\uff0c\u4f7f\u5176\u5206\u5217\u6570\u7ec4\u4e24\u7aef\n    var i = 0\n    var j = ht.size - 1\n    // \u521d\u59cb\u6700\u5927\u5bb9\u91cf\u4e3a 0\n    var res = 0\n    // \u5faa\u73af\u8d2a\u5fc3\u9009\u62e9\uff0c\u76f4\u81f3\u4e24\u677f\u76f8\u9047\n    while (i < j) {\n        // \u66f4\u65b0\u6700\u5927\u5bb9\u91cf\n        val cap = (min(ht[i].toDouble(), ht[j].toDouble()) * (j - i)).toInt()\n        res = max(res.toDouble(), cap.toDouble()).toInt()\n        // \u5411\u5185\u79fb\u52a8\u77ed\u677f\n        if (ht[i] < ht[j]) {\n            i++\n        } else {\n            j--\n        }\n    }\n    return res\n}\n
    max_capacity.rb
    [class]{}-[func]{max_capacity}\n
    max_capacity.zig
    [class]{}-[func]{maxCapacity}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_greedy/max_capacity_problem/#3","title":"3. \u00a0 \u6b63\u786e\u6027\u8bc1\u660e","text":"

    \u4e4b\u6240\u4ee5\u8d2a\u5fc3\u6bd4\u7a77\u4e3e\u66f4\u5feb\uff0c\u662f\u56e0\u4e3a\u6bcf\u8f6e\u7684\u8d2a\u5fc3\u9009\u62e9\u90fd\u4f1a\u201c\u8df3\u8fc7\u201d\u4e00\u4e9b\u72b6\u6001\u3002

    \u6bd4\u5982\u5728\u72b6\u6001 \\(cap[i, j]\\) \u4e0b\uff0c\\(i\\) \u4e3a\u77ed\u677f\u3001\\(j\\) \u4e3a\u957f\u677f\u3002\u82e5\u8d2a\u5fc3\u5730\u5c06\u77ed\u677f \\(i\\) \u5411\u5185\u79fb\u52a8\u4e00\u683c\uff0c\u4f1a\u5bfc\u81f4\u56fe 15-12 \u6240\u793a\u7684\u72b6\u6001\u88ab\u201c\u8df3\u8fc7\u201d\u3002\u8fd9\u610f\u5473\u7740\u4e4b\u540e\u65e0\u6cd5\u9a8c\u8bc1\u8fd9\u4e9b\u72b6\u6001\u7684\u5bb9\u91cf\u5927\u5c0f\u3002

    \\[ cap[i, i+1], cap[i, i+2], \\dots, cap[i, j-2], cap[i, j-1] \\]

    \u56fe 15-12 \u00a0 \u79fb\u52a8\u77ed\u677f\u5bfc\u81f4\u88ab\u8df3\u8fc7\u7684\u72b6\u6001

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u8fd9\u4e9b\u88ab\u8df3\u8fc7\u7684\u72b6\u6001\u5b9e\u9645\u4e0a\u5c31\u662f\u5c06\u957f\u677f \\(j\\) \u5411\u5185\u79fb\u52a8\u7684\u6240\u6709\u72b6\u6001\u3002\u524d\u9762\u6211\u4eec\u5df2\u7ecf\u8bc1\u660e\u5185\u79fb\u957f\u677f\u4e00\u5b9a\u4f1a\u5bfc\u81f4\u5bb9\u91cf\u53d8\u5c0f\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u88ab\u8df3\u8fc7\u7684\u72b6\u6001\u90fd\u4e0d\u53ef\u80fd\u662f\u6700\u4f18\u89e3\uff0c\u8df3\u8fc7\u5b83\u4eec\u4e0d\u4f1a\u5bfc\u81f4\u9519\u8fc7\u6700\u4f18\u89e3\u3002

    \u4ee5\u4e0a\u5206\u6790\u8bf4\u660e\uff0c\u79fb\u52a8\u77ed\u677f\u7684\u64cd\u4f5c\u662f\u201c\u5b89\u5168\u201d\u7684\uff0c\u8d2a\u5fc3\u7b56\u7565\u662f\u6709\u6548\u7684\u3002

    "},{"location":"chapter_greedy/max_product_cutting_problem/","title":"15.4 \u00a0 \u6700\u5927\u5207\u5206\u4e58\u79ef\u95ee\u9898","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u6b63\u6574\u6570 \\(n\\) \uff0c\u5c06\u5176\u5207\u5206\u4e3a\u81f3\u5c11\u4e24\u4e2a\u6b63\u6574\u6570\u7684\u548c\uff0c\u6c42\u5207\u5206\u540e\u6240\u6709\u6574\u6570\u7684\u4e58\u79ef\u6700\u5927\u662f\u591a\u5c11\uff0c\u5982\u56fe 15-13 \u6240\u793a\u3002

    \u56fe 15-13 \u00a0 \u6700\u5927\u5207\u5206\u4e58\u79ef\u7684\u95ee\u9898\u5b9a\u4e49

    \u5047\u8bbe\u6211\u4eec\u5c06 \\(n\\) \u5207\u5206\u4e3a \\(m\\) \u4e2a\u6574\u6570\u56e0\u5b50\uff0c\u5176\u4e2d\u7b2c \\(i\\) \u4e2a\u56e0\u5b50\u8bb0\u4e3a \\(n_i\\) \uff0c\u5373

    \\[ n = \\sum_{i=1}^{m}n_i \\]

    \u672c\u9898\u7684\u76ee\u6807\u662f\u6c42\u5f97\u6240\u6709\u6574\u6570\u56e0\u5b50\u7684\u6700\u5927\u4e58\u79ef\uff0c\u5373

    \\[ \\max(\\prod_{i=1}^{m}n_i) \\]

    \u6211\u4eec\u9700\u8981\u601d\u8003\u7684\u662f\uff1a\u5207\u5206\u6570\u91cf \\(m\\) \u5e94\u8be5\u591a\u5927\uff0c\u6bcf\u4e2a \\(n_i\\) \u5e94\u8be5\u662f\u591a\u5c11\uff1f

    "},{"location":"chapter_greedy/max_product_cutting_problem/#1","title":"1. \u00a0 \u8d2a\u5fc3\u7b56\u7565\u786e\u5b9a","text":"

    \u6839\u636e\u7ecf\u9a8c\uff0c\u4e24\u4e2a\u6574\u6570\u7684\u4e58\u79ef\u5f80\u5f80\u6bd4\u5b83\u4eec\u7684\u52a0\u548c\u66f4\u5927\u3002\u5047\u8bbe\u4ece \\(n\\) \u4e2d\u5206\u51fa\u4e00\u4e2a\u56e0\u5b50 \\(2\\) \uff0c\u5219\u5b83\u4eec\u7684\u4e58\u79ef\u4e3a \\(2(n-2)\\) \u3002\u6211\u4eec\u5c06\u8be5\u4e58\u79ef\u4e0e \\(n\\) \u4f5c\u6bd4\u8f83\uff1a

    \\[ \\begin{aligned} 2(n-2) & \\geq n \\newline 2n - n - 4 & \\geq 0 \\newline n & \\geq 4 \\end{aligned} \\]

    \u5982\u56fe 15-14 \u6240\u793a\uff0c\u5f53 \\(n \\geq 4\\) \u65f6\uff0c\u5207\u5206\u51fa\u4e00\u4e2a \\(2\\) \u540e\u4e58\u79ef\u4f1a\u53d8\u5927\uff0c\u8fd9\u8bf4\u660e\u5927\u4e8e\u7b49\u4e8e \\(4\\) \u7684\u6574\u6570\u90fd\u5e94\u8be5\u88ab\u5207\u5206\u3002

    \u8d2a\u5fc3\u7b56\u7565\u4e00\uff1a\u5982\u679c\u5207\u5206\u65b9\u6848\u4e2d\u5305\u542b \\(\\geq 4\\) \u7684\u56e0\u5b50\uff0c\u90a3\u4e48\u5b83\u5c31\u5e94\u8be5\u88ab\u7ee7\u7eed\u5207\u5206\u3002\u6700\u7ec8\u7684\u5207\u5206\u65b9\u6848\u53ea\u5e94\u51fa\u73b0 \\(1\\)\u3001\\(2\\)\u3001\\(3\\) \u8fd9\u4e09\u79cd\u56e0\u5b50\u3002

    \u56fe 15-14 \u00a0 \u5207\u5206\u5bfc\u81f4\u4e58\u79ef\u53d8\u5927

    \u63a5\u4e0b\u6765\u601d\u8003\u54ea\u4e2a\u56e0\u5b50\u662f\u6700\u4f18\u7684\u3002\u5728 \\(1\\)\u3001\\(2\\)\u3001\\(3\\) \u8fd9\u4e09\u4e2a\u56e0\u5b50\u4e2d\uff0c\u663e\u7136 \\(1\\) \u662f\u6700\u5dee\u7684\uff0c\u56e0\u4e3a \\(1 \\times (n-1) < n\\) \u6052\u6210\u7acb\uff0c\u5373\u5207\u5206\u51fa \\(1\\) \u53cd\u800c\u4f1a\u5bfc\u81f4\u4e58\u79ef\u51cf\u5c0f\u3002

    \u5982\u56fe 15-15 \u6240\u793a\uff0c\u5f53 \\(n = 6\\) \u65f6\uff0c\u6709 \\(3 \\times 3 > 2 \\times 2 \\times 2\\) \u3002\u8fd9\u610f\u5473\u7740\u5207\u5206\u51fa \\(3\\) \u6bd4\u5207\u5206\u51fa \\(2\\) \u66f4\u4f18\u3002

    \u8d2a\u5fc3\u7b56\u7565\u4e8c\uff1a\u5728\u5207\u5206\u65b9\u6848\u4e2d\uff0c\u6700\u591a\u53ea\u5e94\u5b58\u5728\u4e24\u4e2a \\(2\\) \u3002\u56e0\u4e3a\u4e09\u4e2a \\(2\\) \u603b\u662f\u53ef\u4ee5\u66ff\u6362\u4e3a\u4e24\u4e2a \\(3\\) \uff0c\u4ece\u800c\u83b7\u5f97\u66f4\u5927\u7684\u4e58\u79ef\u3002

    \u56fe 15-15 \u00a0 \u6700\u4f18\u5207\u5206\u56e0\u5b50

    \u7efc\u4e0a\u6240\u8ff0\uff0c\u53ef\u63a8\u7406\u51fa\u4ee5\u4e0b\u8d2a\u5fc3\u7b56\u7565\u3002

    1. \u8f93\u5165\u6574\u6570 \\(n\\) \uff0c\u4ece\u5176\u4e0d\u65ad\u5730\u5207\u5206\u51fa\u56e0\u5b50 \\(3\\) \uff0c\u76f4\u81f3\u4f59\u6570\u4e3a \\(0\\)\u3001\\(1\\)\u3001\\(2\\) \u3002
    2. \u5f53\u4f59\u6570\u4e3a \\(0\\) \u65f6\uff0c\u4ee3\u8868 \\(n\\) \u662f \\(3\\) \u7684\u500d\u6570\uff0c\u56e0\u6b64\u4e0d\u505a\u4efb\u4f55\u5904\u7406\u3002
    3. \u5f53\u4f59\u6570\u4e3a \\(2\\) \u65f6\uff0c\u4e0d\u7ee7\u7eed\u5212\u5206\uff0c\u4fdd\u7559\u3002
    4. \u5f53\u4f59\u6570\u4e3a \\(1\\) \u65f6\uff0c\u7531\u4e8e \\(2 \\times 2 > 1 \\times 3\\) \uff0c\u56e0\u6b64\u5e94\u5c06\u6700\u540e\u4e00\u4e2a \\(3\\) \u66ff\u6362\u4e3a \\(2\\) \u3002
    "},{"location":"chapter_greedy/max_product_cutting_problem/#2","title":"2. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5982\u56fe 15-16 \u6240\u793a\uff0c\u6211\u4eec\u65e0\u987b\u901a\u8fc7\u5faa\u73af\u6765\u5207\u5206\u6574\u6570\uff0c\u800c\u53ef\u4ee5\u5229\u7528\u5411\u4e0b\u6574\u9664\u8fd0\u7b97\u5f97\u5230 \\(3\\) \u7684\u4e2a\u6570 \\(a\\) \uff0c\u7528\u53d6\u6a21\u8fd0\u7b97\u5f97\u5230\u4f59\u6570 \\(b\\) \uff0c\u6b64\u65f6\u6709\uff1a

    \\[ n = 3 a + b \\]

    \u8bf7\u6ce8\u610f\uff0c\u5bf9\u4e8e \\(n \\leq 3\\) \u7684\u8fb9\u754c\u60c5\u51b5\uff0c\u5fc5\u987b\u62c6\u5206\u51fa\u4e00\u4e2a \\(1\\) \uff0c\u4e58\u79ef\u4e3a \\(1 \\times (n - 1)\\) \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig max_product_cutting.py
    def max_product_cutting(n: int) -> int:\n    \"\"\"\u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3\"\"\"\n    # \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if n <= 3:\n        return 1 * (n - 1)\n    # \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    a, b = n // 3, n % 3\n    if b == 1:\n        # \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return int(math.pow(3, a - 1)) * 2 * 2\n    if b == 2:\n        # \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return int(math.pow(3, a)) * 2\n    # \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return int(math.pow(3, a))\n
    max_product_cutting.cpp
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint maxProductCutting(int n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return (int)pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return (int)pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return (int)pow(3, a);\n}\n
    max_product_cutting.java
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint maxProductCutting(int n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return (int) Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return (int) Math.pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return (int) Math.pow(3, a);\n}\n
    max_product_cutting.cs
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint MaxProductCutting(int n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return (int)Math.Pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return (int)Math.Pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return (int)Math.Pow(3, a);\n}\n
    max_product_cutting.go
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfunc maxProductCutting(n int) int {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if n <= 3 {\n        return 1 * (n - 1)\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    a := n / 3\n    b := n % 3\n    if b == 1 {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return int(math.Pow(3, float64(a-1))) * 2 * 2\n    }\n    if b == 2 {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return int(math.Pow(3, float64(a))) * 2\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return int(math.Pow(3, float64(a)))\n}\n
    max_product_cutting.swift
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfunc maxProductCutting(n: Int) -> Int {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if n <= 3 {\n        return 1 * (n - 1)\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    let a = n / 3\n    let b = n % 3\n    if b == 1 {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return pow(3, a - 1) * 2 * 2\n    }\n    if b == 2 {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return pow(3, a) * 2\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return pow(3, a)\n}\n
    max_product_cutting.js
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfunction maxProductCutting(n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    let a = Math.floor(n / 3);\n    let b = n % 3;\n    if (b === 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return Math.pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return Math.pow(3, a);\n}\n
    max_product_cutting.ts
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfunction maxProductCutting(n: number): number {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    let a: number = Math.floor(n / 3);\n    let b: number = n % 3;\n    if (b === 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return Math.pow(3, a - 1) * 2 * 2;\n    }\n    if (b === 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return Math.pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return Math.pow(3, a);\n}\n
    max_product_cutting.dart
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint maxProductCutting(int n) {\n  // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n  if (n <= 3) {\n    return 1 * (n - 1);\n  }\n  // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n  int a = n ~/ 3;\n  int b = n % 3;\n  if (b == 1) {\n    // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n    return (pow(3, a - 1) * 2 * 2).toInt();\n  }\n  if (b == 2) {\n    // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return (pow(3, a) * 2).toInt();\n  }\n  // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n  return pow(3, a).toInt();\n}\n
    max_product_cutting.rs
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfn max_product_cutting(n: i32) -> i32 {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if n <= 3 {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    let a = n / 3;\n    let b = n % 3;\n    if b == 1 {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        3_i32.pow(a as u32 - 1) * 2 * 2\n    } else if b == 2 {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        3_i32.pow(a as u32) * 2\n    } else {\n        // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        3_i32.pow(a as u32)\n    }\n}\n
    max_product_cutting.c
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nint maxProductCutting(int n) {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1);\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    int a = n / 3;\n    int b = n % 3;\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return pow(3, a - 1) * 2 * 2;\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return pow(3, a) * 2;\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return pow(3, a);\n}\n
    max_product_cutting.kt
    /* \u6700\u5927\u5207\u5206\u4e58\u79ef\uff1a\u8d2a\u5fc3 */\nfun maxProductCutting(n: Int): Int {\n    // \u5f53 n <= 3 \u65f6\uff0c\u5fc5\u987b\u5207\u5206\u51fa\u4e00\u4e2a 1\n    if (n <= 3) {\n        return 1 * (n - 1)\n    }\n    // \u8d2a\u5fc3\u5730\u5207\u5206\u51fa 3 \uff0ca \u4e3a 3 \u7684\u4e2a\u6570\uff0cb \u4e3a\u4f59\u6570\n    val a = n / 3\n    val b = n % 3\n    if (b == 1) {\n        // \u5f53\u4f59\u6570\u4e3a 1 \u65f6\uff0c\u5c06\u4e00\u5bf9 1 * 3 \u8f6c\u5316\u4e3a 2 * 2\n        return 3.0.pow((a - 1).toDouble()).toInt() * 2 * 2\n    }\n    if (b == 2) {\n        // \u5f53\u4f59\u6570\u4e3a 2 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n        return 3.0.pow(a.toDouble()).toInt() * 2 * 2\n    }\n    // \u5f53\u4f59\u6570\u4e3a 0 \u65f6\uff0c\u4e0d\u505a\u5904\u7406\n    return 3.0.pow(a.toDouble()).toInt()\n}\n
    max_product_cutting.rb
    [class]{}-[func]{max_product_cutting}\n
    max_product_cutting.zig
    [class]{}-[func]{maxProductCutting}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u56fe 15-16 \u00a0 \u6700\u5927\u5207\u5206\u4e58\u79ef\u7684\u8ba1\u7b97\u65b9\u6cd5

    \u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u7f16\u7a0b\u8bed\u8a00\u7684\u5e42\u8fd0\u7b97\u7684\u5b9e\u73b0\u65b9\u6cd5\u3002\u4ee5 Python \u4e3a\u4f8b\uff0c\u5e38\u7528\u7684\u5e42\u8ba1\u7b97\u51fd\u6570\u6709\u4e09\u79cd\u3002

    • \u8fd0\u7b97\u7b26 ** \u548c\u51fd\u6570 pow() \u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5747\u4e3a \\(O(\\log\u2061 a)\\) \u3002
    • \u51fd\u6570 math.pow() \u5185\u90e8\u8c03\u7528 C \u8bed\u8a00\u5e93\u7684 pow() \u51fd\u6570\uff0c\u5176\u6267\u884c\u6d6e\u70b9\u53d6\u5e42\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002

    \u53d8\u91cf \\(a\\) \u548c \\(b\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\uff0c\u56e0\u6b64\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \u3002

    "},{"location":"chapter_greedy/max_product_cutting_problem/#3","title":"3. \u00a0 \u6b63\u786e\u6027\u8bc1\u660e","text":"

    \u4f7f\u7528\u53cd\u8bc1\u6cd5\uff0c\u53ea\u5206\u6790 \\(n \\geq 3\\) \u7684\u60c5\u51b5\u3002

    1. \u6240\u6709\u56e0\u5b50 \\(\\leq 3\\) \uff1a\u5047\u8bbe\u6700\u4f18\u5207\u5206\u65b9\u6848\u4e2d\u5b58\u5728 \\(\\geq 4\\) \u7684\u56e0\u5b50 \\(x\\) \uff0c\u90a3\u4e48\u4e00\u5b9a\u53ef\u4ee5\u5c06\u5176\u7ee7\u7eed\u5212\u5206\u4e3a \\(2(x-2)\\) \uff0c\u4ece\u800c\u83b7\u5f97\u66f4\u5927\u7684\u4e58\u79ef\u3002\u8fd9\u4e0e\u5047\u8bbe\u77db\u76fe\u3002
    2. \u5207\u5206\u65b9\u6848\u4e0d\u5305\u542b \\(1\\) \uff1a\u5047\u8bbe\u6700\u4f18\u5207\u5206\u65b9\u6848\u4e2d\u5b58\u5728\u4e00\u4e2a\u56e0\u5b50 \\(1\\) \uff0c\u90a3\u4e48\u5b83\u4e00\u5b9a\u53ef\u4ee5\u5408\u5e76\u5165\u53e6\u5916\u4e00\u4e2a\u56e0\u5b50\u4e2d\uff0c\u4ee5\u83b7\u5f97\u66f4\u5927\u7684\u4e58\u79ef\u3002\u8fd9\u4e0e\u5047\u8bbe\u77db\u76fe\u3002
    3. \u5207\u5206\u65b9\u6848\u6700\u591a\u5305\u542b\u4e24\u4e2a \\(2\\) \uff1a\u5047\u8bbe\u6700\u4f18\u5207\u5206\u65b9\u6848\u4e2d\u5305\u542b\u4e09\u4e2a \\(2\\) \uff0c\u90a3\u4e48\u4e00\u5b9a\u53ef\u4ee5\u66ff\u6362\u4e3a\u4e24\u4e2a \\(3\\) \uff0c\u4e58\u79ef\u66f4\u5927\u3002\u8fd9\u4e0e\u5047\u8bbe\u77db\u76fe\u3002
    "},{"location":"chapter_greedy/summary/","title":"15.5 \u00a0 \u5c0f\u7ed3","text":"
    • \u8d2a\u5fc3\u7b97\u6cd5\u901a\u5e38\u7528\u4e8e\u89e3\u51b3\u6700\u4f18\u5316\u95ee\u9898\uff0c\u5176\u539f\u7406\u662f\u5728\u6bcf\u4e2a\u51b3\u7b56\u9636\u6bb5\u90fd\u505a\u51fa\u5c40\u90e8\u6700\u4f18\u7684\u51b3\u7b56\uff0c\u4ee5\u671f\u83b7\u5f97\u5168\u5c40\u6700\u4f18\u89e3\u3002
    • \u8d2a\u5fc3\u7b97\u6cd5\u4f1a\u8fed\u4ee3\u5730\u505a\u51fa\u4e00\u4e2a\u53c8\u4e00\u4e2a\u7684\u8d2a\u5fc3\u9009\u62e9\uff0c\u6bcf\u8f6e\u90fd\u5c06\u95ee\u9898\u8f6c\u5316\u6210\u4e00\u4e2a\u89c4\u6a21\u66f4\u5c0f\u7684\u5b50\u95ee\u9898\uff0c\u76f4\u5230\u95ee\u9898\u88ab\u89e3\u51b3\u3002
    • \u8d2a\u5fc3\u7b97\u6cd5\u4e0d\u4ec5\u5b9e\u73b0\u7b80\u5355\uff0c\u8fd8\u5177\u6709\u5f88\u9ad8\u7684\u89e3\u9898\u6548\u7387\u3002\u76f8\u6bd4\u4e8e\u52a8\u6001\u89c4\u5212\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u901a\u5e38\u66f4\u4f4e\u3002
    • \u5728\u96f6\u94b1\u5151\u6362\u95ee\u9898\u4e2d\uff0c\u5bf9\u4e8e\u67d0\u4e9b\u786c\u5e01\u7ec4\u5408\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u53ef\u4ee5\u4fdd\u8bc1\u627e\u5230\u6700\u4f18\u89e3\uff1b\u5bf9\u4e8e\u53e6\u5916\u4e00\u4e9b\u786c\u5e01\u7ec4\u5408\u5219\u4e0d\u7136\uff0c\u8d2a\u5fc3\u7b97\u6cd5\u53ef\u80fd\u627e\u5230\u5f88\u5dee\u7684\u89e3\u3002
    • \u9002\u5408\u7528\u8d2a\u5fc3\u7b97\u6cd5\u6c42\u89e3\u7684\u95ee\u9898\u5177\u6709\u4e24\u5927\u6027\u8d28\uff1a\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u548c\u6700\u4f18\u5b50\u7ed3\u6784\u3002\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u4ee3\u8868\u8d2a\u5fc3\u7b56\u7565\u7684\u6709\u6548\u6027\u3002
    • \u5bf9\u4e8e\u67d0\u4e9b\u590d\u6742\u95ee\u9898\uff0c\u8d2a\u5fc3\u9009\u62e9\u6027\u8d28\u7684\u8bc1\u660e\u5e76\u4e0d\u7b80\u5355\u3002\u76f8\u5bf9\u6765\u8bf4\uff0c\u8bc1\u4f2a\u66f4\u52a0\u5bb9\u6613\uff0c\u4f8b\u5982\u96f6\u94b1\u5151\u6362\u95ee\u9898\u3002
    • \u6c42\u89e3\u8d2a\u5fc3\u95ee\u9898\u4e3b\u8981\u5206\u4e3a\u4e09\u6b65\uff1a\u95ee\u9898\u5206\u6790\u3001\u786e\u5b9a\u8d2a\u5fc3\u7b56\u7565\u3001\u6b63\u786e\u6027\u8bc1\u660e\u3002\u5176\u4e2d\uff0c\u786e\u5b9a\u8d2a\u5fc3\u7b56\u7565\u662f\u6838\u5fc3\u6b65\u9aa4\uff0c\u6b63\u786e\u6027\u8bc1\u660e\u5f80\u5f80\u662f\u96be\u70b9\u3002
    • \u5206\u6570\u80cc\u5305\u95ee\u9898\u5728 0-1 \u80cc\u5305\u7684\u57fa\u7840\u4e0a\uff0c\u5141\u8bb8\u9009\u62e9\u7269\u54c1\u7684\u4e00\u90e8\u5206\uff0c\u56e0\u6b64\u53ef\u4f7f\u7528\u8d2a\u5fc3\u7b97\u6cd5\u6c42\u89e3\u3002\u8d2a\u5fc3\u7b56\u7565\u7684\u6b63\u786e\u6027\u53ef\u4ee5\u4f7f\u7528\u53cd\u8bc1\u6cd5\u6765\u8bc1\u660e\u3002
    • \u6700\u5927\u5bb9\u91cf\u95ee\u9898\u53ef\u4f7f\u7528\u7a77\u4e3e\u6cd5\u6c42\u89e3\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\) \u3002\u901a\u8fc7\u8bbe\u8ba1\u8d2a\u5fc3\u7b56\u7565\uff0c\u6bcf\u8f6e\u5411\u5185\u79fb\u52a8\u77ed\u677f\uff0c\u53ef\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(n)\\) \u3002
    • \u5728\u6700\u5927\u5207\u5206\u4e58\u79ef\u95ee\u9898\u4e2d\uff0c\u6211\u4eec\u5148\u540e\u63a8\u7406\u51fa\u4e24\u4e2a\u8d2a\u5fc3\u7b56\u7565\uff1a\\(\\geq 4\\) \u7684\u6574\u6570\u90fd\u5e94\u8be5\u7ee7\u7eed\u5207\u5206\uff0c\u6700\u4f18\u5207\u5206\u56e0\u5b50\u4e3a \\(3\\) \u3002\u4ee3\u7801\u4e2d\u5305\u542b\u5e42\u8fd0\u7b97\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u53d6\u51b3\u4e8e\u5e42\u8fd0\u7b97\u5b9e\u73b0\u65b9\u6cd5\uff0c\u901a\u5e38\u4e3a \\(O(1)\\) \u6216 \\(O(\\log n)\\) \u3002
    "},{"location":"chapter_hashing/","title":"\u7b2c 6 \u7ae0 \u00a0 \u54c8\u5e0c\u8868","text":"

    Abstract

    \u5728\u8ba1\u7b97\u673a\u4e16\u754c\u4e2d\uff0c\u54c8\u5e0c\u8868\u5982\u540c\u4e00\u4f4d\u806a\u6167\u7684\u56fe\u4e66\u7ba1\u7406\u5458\u3002

    \u4ed6\u77e5\u9053\u5982\u4f55\u8ba1\u7b97\u7d22\u4e66\u53f7\uff0c\u4ece\u800c\u53ef\u4ee5\u5feb\u901f\u627e\u5230\u76ee\u6807\u56fe\u4e66\u3002

    "},{"location":"chapter_hashing/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 6.1 \u00a0 \u54c8\u5e0c\u8868
    • 6.2 \u00a0 \u54c8\u5e0c\u51b2\u7a81
    • 6.3 \u00a0 \u54c8\u5e0c\u7b97\u6cd5
    • 6.4 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_hashing/hash_algorithm/","title":"6.3 \u00a0 \u54c8\u5e0c\u7b97\u6cd5","text":"

    \u524d\u4e24\u8282\u4ecb\u7ecd\u4e86\u54c8\u5e0c\u8868\u7684\u5de5\u4f5c\u539f\u7406\u548c\u54c8\u5e0c\u51b2\u7a81\u7684\u5904\u7406\u65b9\u6cd5\u3002\u7136\u800c\u65e0\u8bba\u662f\u5f00\u653e\u5bfb\u5740\u8fd8\u662f\u94fe\u5f0f\u5730\u5740\uff0c\u5b83\u4eec\u53ea\u80fd\u4fdd\u8bc1\u54c8\u5e0c\u8868\u53ef\u4ee5\u5728\u53d1\u751f\u51b2\u7a81\u65f6\u6b63\u5e38\u5de5\u4f5c\uff0c\u800c\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\u5982\u56fe 6-8 \u6240\u793a\uff0c\u5bf9\u4e8e\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\uff0c\u7406\u60f3\u60c5\u51b5\u4e0b\u952e\u503c\u5bf9\u5747\u5300\u5206\u5e03\u5728\u5404\u4e2a\u6876\u4e2d\uff0c\u8fbe\u5230\u6700\u4f73\u67e5\u8be2\u6548\u7387\uff1b\u6700\u5dee\u60c5\u51b5\u4e0b\u6240\u6709\u952e\u503c\u5bf9\u90fd\u5b58\u50a8\u5230\u540c\u4e00\u4e2a\u6876\u4e2d\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u9000\u5316\u81f3 \\(O(n)\\) \u3002

    \u56fe 6-8 \u00a0 \u54c8\u5e0c\u51b2\u7a81\u7684\u6700\u4f73\u60c5\u51b5\u4e0e\u6700\u5dee\u60c5\u51b5

    \u952e\u503c\u5bf9\u7684\u5206\u5e03\u60c5\u51b5\u7531\u54c8\u5e0c\u51fd\u6570\u51b3\u5b9a\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\u60c5\u51b5\u3002

    \u8fd9\u610f\u5473\u7740\uff0c\u4e3a\u4e86\u964d\u4f4e\u54c8\u5e0c\u51b2\u7a81\u7684\u53d1\u751f\u6982\u7387\uff0c\u6211\u4eec\u5e94\u5f53\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\u5b9e\u73b0\u201c\u65e2\u5feb\u53c8\u7a33\u201d\u7684\u54c8\u5e0c\u8868\u6570\u636e\u7ed3\u6784\uff0c\u54c8\u5e0c\u7b97\u6cd5\u5e94\u5177\u5907\u4ee5\u4e0b\u7279\u70b9\u3002

    • \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\u5747\u5300\u5206\u5e03\u5728\u54c8\u5e0c\u8868\u4e2d\u3002\u5206\u5e03\u8d8a\u5747\u5300\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\u3002

    • \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\u3002

    \u5bf9\u4e8e\u5bc6\u7801\u5b66\u7684\u76f8\u5173\u5e94\u7528\uff0c\u4e3a\u4e86\u9632\u6b62\u4ece\u54c8\u5e0c\u503c\u63a8\u5bfc\u51fa\u539f\u59cb\u5bc6\u7801\u7b49\u9006\u5411\u5de5\u7a0b\uff0c\u54c8\u5e0c\u7b97\u6cd5\u9700\u8981\u5177\u5907\u66f4\u9ad8\u7b49\u7ea7\u7684\u5b89\u5168\u7279\u6027\u3002

    • \u5355\u5411\u6027\uff1a\u65e0\u6cd5\u901a\u8fc7\u54c8\u5e0c\u503c\u53cd\u63a8\u51fa\u5173\u4e8e\u8f93\u5165\u6570\u636e\u7684\u4efb\u4f55\u4fe1\u606f\u3002
    • \u6297\u78b0\u649e\u6027\uff1a\u5e94\u5f53\u6781\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

    \u8bf7\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\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\u9700\u8981\u8003\u8651\u8bb8\u591a\u56e0\u7d20\u7684\u590d\u6742\u95ee\u9898\u3002\u7136\u800c\u5bf9\u4e8e\u67d0\u4e9b\u8981\u6c42\u4e0d\u9ad8\u7684\u573a\u666f\uff0c\u6211\u4eec\u4e5f\u80fd\u8bbe\u8ba1\u4e00\u4e9b\u7b80\u5355\u7684\u54c8\u5e0c\u7b97\u6cd5\u3002

    • \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\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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig simple_hash.py
    def add_hash(key: str) -> int:\n    \"\"\"\u52a0\u6cd5\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash += ord(c)\n    return hash % modulus\n\ndef mul_hash(key: str) -> int:\n    \"\"\"\u4e58\u6cd5\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = 31 * hash + ord(c)\n    return hash % modulus\n\ndef xor_hash(key: str) -> int:\n    \"\"\"\u5f02\u6216\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash ^= ord(c)\n    return hash % modulus\n\ndef rot_hash(key: str) -> int:\n    \"\"\"\u65cb\u8f6c\u54c8\u5e0c\"\"\"\n    hash = 0\n    modulus = 1000000007\n    for c in key:\n        hash = (hash << 4) ^ (hash >> 28) ^ ord(c)\n    return hash % modulus\n
    simple_hash.cpp
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = (31 * hash + (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash ^= (int)c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(string key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (unsigned char c : key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;\n    }\n    return (int)hash;\n}\n
    simple_hash.java
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = (31 * hash + (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\n    int hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash ^= (int) c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\n    long hash = 0;\n    final int MODULUS = 1000000007;\n    for (char c : key.toCharArray()) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;\n    }\n    return (int) hash;\n}\n
    simple_hash.cs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint AddHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint MulHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = (31 * hash + c) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint XorHash(string key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash ^= c;\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint RotHash(string key) {\n    long hash = 0;\n    const int MODULUS = 1000000007;\n    foreach (char c in key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;\n    }\n    return (int)hash;\n}\n
    simple_hash.go
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = (31*hash + int64(b)) % modulus\n    }\n    return int(hash)\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key string) int {\n    hash := 0\n    modulus := 1000000007\n    for _, b := range []byte(key) {\n        fmt.Println(int(b))\n        hash ^= int(b)\n        hash = (31*hash + int(b)) % modulus\n    }\n    return hash & modulus\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key string) int {\n    var hash int64\n    var modulus int64\n\n    modulus = 1000000007\n    for _, b := range []byte(key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus\n    }\n    return int(hash)\n}\n
    simple_hash.swift
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunc addHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunc mulHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = (31 * hash + Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunc xorHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash ^= Int(scalar.value)\n        }\n    }\n    return hash & MODULUS\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunc rotHash(key: String) -> Int {\n    var hash = 0\n    let MODULUS = 1_000_000_007\n    for c in key {\n        for scalar in c.unicodeScalars {\n            hash = ((hash << 4) ^ (hash >> 28) ^ Int(scalar.value)) % MODULUS\n        }\n    }\n    return hash\n}\n
    simple_hash.js
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunction addHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunction mulHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunction xorHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunction rotHash(key) {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n
    simple_hash.ts
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfunction addHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfunction mulHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = (31 * hash + c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfunction xorHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash ^= c.charCodeAt(0);\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfunction rotHash(key: string): number {\n    let hash = 0;\n    const MODULUS = 1000000007;\n    for (const c of key) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;\n    }\n    return hash;\n}\n
    simple_hash.dart
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = (hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash ^= key.codeUnitAt(i);\n  }\n  return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(String key) {\n  int hash = 0;\n  final int MODULUS = 1000000007;\n  for (int i = 0; i < key.length; i++) {\n    hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;\n  }\n  return hash;\n}\n
    simple_hash.rs
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfn add_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfn mul_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = (31 * hash + c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfn xor_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash ^= c as i64;\n    }\n\n    (hash & MODULUS) as i32\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfn rot_hash(key: &str) -> i32 {\n    let mut hash = 0_i64;\n    const MODULUS: i64 = 1000000007;\n\n    for c in key.chars() {\n        hash = ((hash << 4) ^ (hash >> 28) ^ c as i64) % MODULUS;\n    }\n\n    hash as i32\n}\n
    simple_hash.c
    /* \u52a0\u6cd5\u54c8\u5e0c */\nint addHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = (hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nint mulHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = (31 * hash + (unsigned char)key[i]) % MODULUS;\n    }\n    return (int)hash;\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nint xorHash(char *key) {\n    int hash = 0;\n    const int MODULUS = 1000000007;\n\n    for (int i = 0; i < strlen(key); i++) {\n        hash ^= (unsigned char)key[i];\n    }\n    return hash & MODULUS;\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nint rotHash(char *key) {\n    long long hash = 0;\n    const int MODULUS = 1000000007;\n    for (int i = 0; i < strlen(key); i++) {\n        hash = ((hash << 4) ^ (hash >> 28) ^ (unsigned char)key[i]) % MODULUS;\n    }\n\n    return (int)hash;\n}\n
    simple_hash.kt
    /* \u52a0\u6cd5\u54c8\u5e0c */\nfun addHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = (hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* \u4e58\u6cd5\u54c8\u5e0c */\nfun mulHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = (31 * hash + c.code) % MODULUS\n    }\n    return hash.toInt()\n}\n\n/* \u5f02\u6216\u54c8\u5e0c */\nfun xorHash(key: String): Int {\n    var hash = 0\n    for (c in key.toCharArray()) {\n        hash = hash xor c.code\n    }\n    return hash and MODULUS\n}\n\n/* \u65cb\u8f6c\u54c8\u5e0c */\nfun rotHash(key: String): Int {\n    var hash = 0L\n    for (c in key.toCharArray()) {\n        hash = ((hash shl 4) xor (hash shr 28) xor c.code.toLong()) % MODULUS\n    }\n    return hash.toInt()\n}\n
    simple_hash.rb
    [class]{}-[func]{add_hash}\n\n[class]{}-[func]{mul_hash}\n\n[class]{}-[func]{xor_hash}\n\n[class]{}-[func]{rot_hash}\n
    simple_hash.zig
    [class]{}-[func]{addHash}\n\n[class]{}-[func]{mulHash}\n\n[class]{}-[func]{xorHash}\n\n[class]{}-[func]{rotHash}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\u6216\u8005\u8bf4\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\u4f7f\u7528\u5927\u8d28\u6570\u4f5c\u4e3a\u6a21\u6570\uff0c\u53ef\u4ee5\u6700\u5927\u5316\u5730\u4fdd\u8bc1\u54c8\u5e0c\u503c\u7684\u5747\u5300\u5206\u5e03\u3002\u56e0\u4e3a\u8d28\u6570\u4e0d\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\uff0c\u90a3\u4e48\u6240\u6709\u53ef\u4ee5\u88ab \\(3\\) \u6574\u9664\u7684 key \u90fd\u4f1a\u88ab\u6620\u5c04\u5230 \\(0\\)\u3001\\(3\\)\u3001\\(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, \\dots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6,\\dots \\} \\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\u56e0\u6b64\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, \\dots \\} \\newline \\text{hash} & = \\{ 0, 3, 6, 9, 12, 2, 5, 8, 11, 1, 4, 7, \\dots \\} \\end{aligned} \\]

    \u503c\u5f97\u8bf4\u660e\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\u53ef\u4ee5\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\u8db3\u591f\u5927\uff0c\u4ee5\u5c3d\u53ef\u80fd\u6d88\u9664\u5468\u671f\u6027\u6a21\u5f0f\uff0c\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\u3001SHA-1\u3001SHA-2 \u548c SHA-3 \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\u8868 6-2 \u5c55\u793a\u4e86\u5728\u5b9e\u9645\u5e94\u7528\u4e2d\u5e38\u89c1\u7684\u54c8\u5e0c\u7b97\u6cd5\u3002

    • MD5 \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\u3002
    • SHA-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\u7528\u5728\u5404\u7c7b\u5b89\u5168\u5e94\u7528\u4e0e\u534f\u8bae\u4e2d\u3002
    • SHA-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

    \u8868 6-2 \u00a0 \u5e38\u89c1\u7684\u54c8\u5e0c\u7b97\u6cd5

    MD5 SHA-1 SHA-2 SHA-3 \u63a8\u51fa\u65f6\u95f4 1992 1995 2002 2008 \u8f93\u51fa\u957f\u5ea6 128 bit 160 bit 256/512 bit 224/256/384/512 bit \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\u3002

    • \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\u8bfb\u8005\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig built_in_hash.py
    num = 3\nhash_num = hash(num)\n# \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\n\nbol = True\nhash_bol = hash(bol)\n# \u5e03\u5c14\u91cf True \u7684\u54c8\u5e0c\u503c\u4e3a 1\n\ndec = 3.14159\nhash_dec = hash(dec)\n# \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 326484311674566659\n\nstr = \"Hello \u7b97\u6cd5\"\nhash_str = hash(str)\n# \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a 4617003410720528961\n\ntup = (12836, \"\u5c0f\u54c8\")\nhash_tup = hash(tup)\n# \u5143\u7ec4 (12836, '\u5c0f\u54c8') \u7684\u54c8\u5e0c\u503c\u4e3a 1029005403108185979\n\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.cpp
    int num = 3;\nsize_t hashNum = hash<int>()(num);\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\n\nbool bol = true;\nsize_t hashBol = hash<bool>()(bol);\n// \u5e03\u5c14\u91cf 1 \u7684\u54c8\u5e0c\u503c\u4e3a 1\n\ndouble dec = 3.14159;\nsize_t hashDec = hash<double>()(dec);\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 4614256650576692846\n\nstring str = \"Hello \u7b97\u6cd5\";\nsize_t hashStr = hash<string>()(str);\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a 15466937326284535026\n\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.java
    int num = 3;\nint hashNum = Integer.hashCode(num);\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\n\nboolean bol = true;\nint hashBol = Boolean.hashCode(bol);\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\n\ndouble dec = 3.14159;\nint hashDec = Double.hashCode(dec);\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729\n\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode();\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a -727081396\n\nObject[] arr = { 12836, \"\u5c0f\u54c8\" };\nint hashTup = Arrays.hashCode(arr);\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 1151158\n\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.cs
    int num = 3;\nint hashNum = num.GetHashCode();\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3;\n\nbool bol = true;\nint hashBol = bol.GetHashCode();\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1;\n\ndouble dec = 3.14159;\nint hashDec = dec.GetHashCode();\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729;\n\nstring str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.GetHashCode();\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a -586107568;\n\nobject[] arr = [12836, \"\u5c0f\u54c8\"];\nint hashTup = arr.GetHashCode();\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 42931033;\n\nListNode obj = new(0);\nint hashObj = obj.GetHashCode();\n// \u8282\u70b9\u5bf9\u8c61 0 \u7684\u54c8\u5e0c\u503c\u4e3a 39053774;\n
    built_in_hash.go
    // Go \u672a\u63d0\u4f9b\u5185\u7f6e hash code \u51fd\u6570\n
    built_in_hash.swift
    let num = 3\nlet hashNum = num.hashValue\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 9047044699613009734\n\nlet bol = true\nlet hashBol = bol.hashValue\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a -4431640247352757451\n\nlet dec = 3.14159\nlet hashDec = dec.hashValue\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -2465384235396674631\n\nlet str = \"Hello \u7b97\u6cd5\"\nlet hashStr = str.hashValue\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a -7850626797806988787\n\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\n\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.js
    // JavaScript \u672a\u63d0\u4f9b\u5185\u7f6e hash code \u51fd\u6570\n
    built_in_hash.ts
    // TypeScript \u672a\u63d0\u4f9b\u5185\u7f6e hash code \u51fd\u6570\n
    built_in_hash.dart
    int num = 3;\nint hashNum = num.hashCode;\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 34803\n\nbool bol = true;\nint hashBol = bol.hashCode;\n// \u5e03\u5c14\u503c true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\n\ndouble dec = 3.14159;\nint hashDec = dec.hashCode;\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 2570631074981783\n\nString str = \"Hello \u7b97\u6cd5\";\nint hashStr = str.hashCode;\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a 468167534\n\nList arr = [12836, \"\u5c0f\u54c8\"];\nint hashArr = arr.hashCode;\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 976512528\n\nListNode obj = new ListNode(0);\nint hashObj = obj.hashCode;\n// \u8282\u70b9\u5bf9\u8c61 Instance of 'ListNode' \u7684\u54c8\u5e0c\u503c\u4e3a 1033450432\n
    built_in_hash.rs
    use std::collections::hash_map::DefaultHasher;\nuse std::hash::{Hash, Hasher};\n\nlet num = 3;\nlet mut num_hasher = DefaultHasher::new();\nnum.hash(&mut num_hasher);\nlet hash_num = num_hasher.finish();\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 568126464209439262\n\nlet bol = true;\nlet mut bol_hasher = DefaultHasher::new();\nbol.hash(&mut bol_hasher);\nlet hash_bol = bol_hasher.finish();\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 4952851536318644461\n\nlet dec: f32 = 3.14159;\nlet mut dec_hasher = DefaultHasher::new();\ndec.to_bits().hash(&mut dec_hasher);\nlet hash_dec = dec_hasher.finish();\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a 2566941990314602357\n\nlet str = \"Hello \u7b97\u6cd5\";\nlet mut str_hasher = DefaultHasher::new();\nstr.hash(&mut str_hasher);\nlet hash_str = str_hasher.finish();\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a 16092673739211250988\n\nlet arr = (&12836, &\"\u5c0f\u54c8\");\nlet mut tup_hasher = DefaultHasher::new();\narr.hash(&mut tup_hasher);\nlet hash_tup = tup_hasher.finish();\n// \u5143\u7ec4 (12836, \"\u5c0f\u54c8\") \u7684\u54c8\u5e0c\u503c\u4e3a 1885128010422702749\n\nlet node = ListNode::new(42);\nlet mut hasher = DefaultHasher::new();\nnode.borrow().val.hash(&mut hasher);\nlet hash = hasher.finish();\n// \u8282\u70b9\u5bf9\u8c61 RefCell { value: ListNode { val: 42, next: None } } \u7684\u54c8\u5e0c\u503c\u4e3a15387811073369036852\n
    built_in_hash.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e hash code \u51fd\u6570\n
    built_in_hash.kt
    val num = 3\nval hashNum = num.hashCode()\n// \u6574\u6570 3 \u7684\u54c8\u5e0c\u503c\u4e3a 3\n\nval bol = true\nval hashBol = bol.hashCode()\n// \u5e03\u5c14\u91cf true \u7684\u54c8\u5e0c\u503c\u4e3a 1231\n\nval dec = 3.14159\nval hashDec = dec.hashCode()\n// \u5c0f\u6570 3.14159 \u7684\u54c8\u5e0c\u503c\u4e3a -1340954729\n\nval str = \"Hello \u7b97\u6cd5\"\nval hashStr = str.hashCode()\n// \u5b57\u7b26\u4e32\u201cHello \u7b97\u6cd5\u201d\u7684\u54c8\u5e0c\u503c\u4e3a -727081396\n\nval arr = arrayOf<Any>(12836, \"\u5c0f\u54c8\")\nval hashTup = arr.hashCode()\n// \u6570\u7ec4 [12836, \u5c0f\u54c8] \u7684\u54c8\u5e0c\u503c\u4e3a 189568618\n\nval obj = ListNode(0)\nval hashObj = obj.hashCode()\n// \u8282\u70b9\u5bf9\u8c61 utils.ListNode@1d81eb93 \u7684\u54c8\u5e0c\u503c\u4e3a 495053715\n
    built_in_hash.rb
    \n
    built_in_hash.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5728\u8bb8\u591a\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\u6bd4\u5982\u94fe\u8868\u8282\u70b9\uff09\u7684\u6210\u5458\u53d8\u91cf\u662f\u53ef\u53d8\u7684\uff0c\u4f46\u5b83\u662f\u53ef\u54c8\u5e0c\u7684\u3002\u8fd9\u662f\u56e0\u4e3a\u5bf9\u8c61\u7684\u54c8\u5e0c\u503c\u901a\u5e38\u662f\u57fa\u4e8e\u5185\u5b58\u5730\u5740\u751f\u6210\u7684\uff0c\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

    \u7ec6\u5fc3\u7684\u4f60\u53ef\u80fd\u53d1\u73b0\u5728\u4e0d\u540c\u63a7\u5236\u53f0\u4e2d\u8fd0\u884c\u7a0b\u5e8f\u65f6\uff0c\u8f93\u51fa\u7684\u54c8\u5e0c\u503c\u662f\u4e0d\u540c\u7684\u3002\u8fd9\u662f\u56e0\u4e3a 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\u8fd9\u79cd\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\u4e00\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\u7406\u8bba\u4e0a\u54c8\u5e0c\u51b2\u7a81\u662f\u4e0d\u53ef\u907f\u514d\u7684\u3002\u6bd4\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\u6876\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\u4e86\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6bcf\u5f53\u9047\u5230\u54c8\u5e0c\u51b2\u7a81\u65f6\uff0c\u6211\u4eec\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\u53ef\u4ee5\u91c7\u7528\u4ee5\u4e0b\u7b56\u7565\u3002

    1. \u6539\u826f\u54c8\u5e0c\u8868\u6570\u636e\u7ed3\u6784\uff0c\u4f7f\u5f97\u54c8\u5e0c\u8868\u53ef\u4ee5\u5728\u51fa\u73b0\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\u624d\u6267\u884c\u6269\u5bb9\u64cd\u4f5c\u3002

    \u54c8\u5e0c\u8868\u7684\u7ed3\u6784\u6539\u826f\u65b9\u6cd5\u4e3b\u8981\u5305\u62ec\u201c\u94fe\u5f0f\u5730\u5740\u201d\u548c\u201c\u5f00\u653e\u5bfb\u5740\u201d\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\u56fe 6-5 \u5c55\u793a\u4e86\u4e00\u4e2a\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\u7684\u4f8b\u5b50\u3002

    \u56fe 6-5 \u00a0 \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868

    \u57fa\u4e8e\u94fe\u5f0f\u5730\u5740\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\u7684\u64cd\u4f5c\u65b9\u6cd5\u53d1\u751f\u4e86\u4ee5\u4e0b\u53d8\u5316\u3002

    • \u67e5\u8be2\u5143\u7d20\uff1a\u8f93\u5165 key \uff0c\u7ecf\u8fc7\u54c8\u5e0c\u51fd\u6570\u5f97\u5230\u6876\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\u9996\u5148\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u8bbf\u95ee\u94fe\u8868\u5934\u8282\u70b9\uff0c\u7136\u540e\u5c06\u8282\u70b9\uff08\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\u5e76\u5c06\u5176\u5220\u9664\u3002

    \u94fe\u5f0f\u5730\u5740\u5b58\u5728\u4ee5\u4e0b\u5c40\u9650\u6027\u3002

    • \u5360\u7528\u7a7a\u95f4\u589e\u5927\uff1a\u94fe\u8868\u5305\u542b\u8282\u70b9\u6307\u9488\uff0c\u5b83\u76f8\u6bd4\u6570\u7ec4\u66f4\u52a0\u8017\u8d39\u5185\u5b58\u7a7a\u95f4\u3002
    • \u67e5\u8be2\u6548\u7387\u964d\u4f4e\uff1a\u56e0\u4e3a\u9700\u8981\u7ebf\u6027\u904d\u5386\u94fe\u8868\u6765\u67e5\u627e\u5bf9\u5e94\u5143\u7d20\u3002

    \u4ee5\u4e0b\u4ee3\u7801\u7ed9\u51fa\u4e86\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\u7684\u7b80\u5355\u5b9e\u73b0\uff0c\u9700\u8981\u6ce8\u610f\u4e24\u70b9\u3002

    • \u4f7f\u7528\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\u4ee3\u66ff\u94fe\u8868\uff0c\u4ece\u800c\u7b80\u5316\u4ee3\u7801\u3002\u5728\u8fd9\u79cd\u8bbe\u5b9a\u4e0b\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\u5b9e\u73b0\u5305\u542b\u54c8\u5e0c\u8868\u6269\u5bb9\u65b9\u6cd5\u3002\u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7 \\(\\frac{2}{3}\\) \u65f6\uff0c\u6211\u4eec\u5c06\u54c8\u5e0c\u8868\u6269\u5bb9\u81f3\u539f\u5148\u7684 \\(2\\) \u500d\u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map_chaining.py
    class HashMapChaining:\n    \"\"\"\u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\n        self.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\n        self.load_thres = 2.0 / 3.0  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        self.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\n        self.buckets = [[] for _ in range(self.capacity)]  # \u6876\u6570\u7ec4\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -> float:\n        \"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\n        return self.size / self.capacity\n\n    def get(self, key: int) -> str | None:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket:\n            if pair.key == key:\n                return pair.val\n        # \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        return None\n\n    def 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\n        if self.load_factor() > self.load_thres:\n            self.extend()\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket:\n            if pair.key == key:\n                pair.val = val\n                return\n        # \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        pair = Pair(key, val)\n        bucket.append(pair)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        index = self.hash_func(key)\n        bucket = self.buckets[index]\n        # \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for pair in bucket:\n            if pair.key == key:\n                bucket.remove(pair)\n                self.size -= 1\n                break\n\n    def extend(self):\n        \"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n        # \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        buckets = self.buckets\n        # \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio\n        self.buckets = [[] for _ in range(self.capacity)]\n        self.size = 0\n        # \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in buckets:\n            for pair in bucket:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for bucket in self.buckets:\n            res = []\n            for pair in bucket:\n                res.append(str(pair.key) + \" -> \" + pair.val)\n            print(res)\n
    hash_map_chaining.cpp
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n  private:\n    int size;                       // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;                   // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres;               // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;                // \u6269\u5bb9\u500d\u6570\n    vector<vector<Pair *>> buckets; // \u6876\u6570\u7ec4\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    HashMapChaining() : size(0), capacity(4), loadThres(2.0 / 3.0), extendRatio(2) {\n        buckets.resize(capacity);\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~HashMapChaining() {\n        for (auto &bucket : buckets) {\n            for (Pair *pair : bucket) {\n                // \u91ca\u653e\u5185\u5b58\n                delete pair;\n            }\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double)size / (double)capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        int index = hashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (Pair *pair : buckets[index]) {\n            if (pair->key == key) {\n                return pair->val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n        return \"\";\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (Pair *pair : buckets[index]) {\n            if (pair->key == key) {\n                pair->val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        buckets[index].push_back(new Pair(key, val));\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        auto &bucket = buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (int i = 0; i < bucket.size(); i++) {\n            if (bucket[i]->key == key) {\n                Pair *tmp = bucket[i];\n                bucket.erase(bucket.begin() + i); // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n                delete tmp;                       // \u91ca\u653e\u5185\u5b58\n                size--;\n                return;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        vector<vector<Pair *>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets.clear();\n        buckets.resize(capacity);\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (auto &bucket : bucketsTmp) {\n            for (Pair *pair : bucket) {\n                put(pair->key, pair->val);\n                // \u91ca\u653e\u5185\u5b58\n                delete pair;\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (auto &bucket : buckets) {\n            cout << \"[\";\n            for (Pair *pair : bucket) {\n                cout << pair->key << \" -> \" << pair->val << \", \";\n            }\n            cout << \"]\\n\";\n        }\n    }\n};\n
    hash_map_chaining.java
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio; // \u6269\u5bb9\u500d\u6570\n    List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new ArrayList<>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.add(new ArrayList<>());\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    String get(int key) {\n        int index = hashFunc(key);\n        List<Pair> bucket = buckets.get(index);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, String val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        int index = hashFunc(key);\n        List<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\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        Pair pair = new Pair(key, val);\n        bucket.add(pair);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        List<Pair> bucket = buckets.get(index);\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (Pair pair : bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        List<List<Pair>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new ArrayList<>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.add(new ArrayList<>());\n        }\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (List<Pair> bucket : bucketsTmp) {\n            for (Pair pair : bucket) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (List<Pair> bucket : buckets) {\n            List<String> res = new ArrayList<>();\n            for (Pair pair : bucket) {\n                res.add(pair.key + \" -> \" + pair.val);\n            }\n            System.out.println(res);\n        }\n    }\n}\n
    hash_map_chaining.cs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio; // \u6269\u5bb9\u500d\u6570\n    List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapChaining() {\n        size = 0;\n        capacity = 4;\n        loadThres = 2.0 / 3.0;\n        extendRatio = 2;\n        buckets = new List<List<Pair>>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.Add([]);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (LoadFactor() > loadThres) {\n            Extend();\n        }\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        foreach (Pair pair in buckets[index]) {\n            if (pair.key == key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        buckets[index].Add(new Pair(key, val));\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        foreach (Pair pair in buckets[index].ToList()) {\n            if (pair.key == key) {\n                buckets[index].Remove(pair);\n                size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void Extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        List<List<Pair>> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new List<List<Pair>>(capacity);\n        for (int i = 0; i < capacity; i++) {\n            buckets.Add([]);\n        }\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        foreach (List<Pair> bucket in bucketsTmp) {\n            foreach (Pair pair in bucket) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (List<Pair> bucket in buckets) {\n            List<string> res = [];\n            foreach (Pair pair in bucket) {\n                res.Add(pair.key + \" -> \" + pair.val);\n            }\n            foreach (string kv in res) {\n                Console.WriteLine(kv);\n            }\n        }\n    }\n}\n
    hash_map_chaining.go
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntype hashMapChaining struct {\n    size        int      // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity    int      // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    loadThres   float64  // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extendRatio int      // \u6269\u5bb9\u500d\u6570\n    buckets     [][]pair // \u6876\u6570\u7ec4\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapChaining() *hashMapChaining {\n    buckets := make([][]pair, 4)\n    for i := 0; i < 4; i++ {\n        buckets[i] = make([]pair, 0)\n    }\n    return &hashMapChaining{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     buckets,\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (m *hashMapChaining) hashFunc(key int) int {\n    return key % m.capacity\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (m *hashMapChaining) loadFactor() float64 {\n    return float64(m.size) / float64(m.capacity)\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (m *hashMapChaining) get(key int) string {\n    idx := m.hashFunc(key)\n    bucket := m.buckets[idx]\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    for _, p := range bucket {\n        if p.key == key {\n            return p.val\n        }\n    }\n    // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n    return \"\"\n}\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\n    if m.loadFactor() > m.loadThres {\n        m.extend()\n    }\n    idx := m.hashFunc(key)\n    // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n    for i := range m.buckets[idx] {\n        if m.buckets[idx][i].key == key {\n            m.buckets[idx][i].val = val\n            return\n        }\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n    p := pair{\n        key: key,\n        val: val,\n    }\n    m.buckets[idx] = append(m.buckets[idx], p)\n    m.size += 1\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (m *hashMapChaining) remove(key int) {\n    idx := m.hashFunc(key)\n    // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n    for i, p := range m.buckets[idx] {\n        if p.key == key {\n            // \u5207\u7247\u5220\u9664\n            m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)\n            m.size -= 1\n            break\n        }\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    tmpBuckets := make([][]pair, len(m.buckets))\n    for i := 0; i < len(m.buckets); i++ {\n        tmpBuckets[i] = make([]pair, len(m.buckets[i]))\n        copy(tmpBuckets[i], m.buckets[i])\n    }\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    m.capacity *= m.extendRatio\n    m.buckets = make([][]pair, m.capacity)\n    for i := 0; i < m.capacity; i++ {\n        m.buckets[i] = make([]pair, 0)\n    }\n    m.size = 0\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for _, bucket := range tmpBuckets {\n        for _, p := range bucket {\n            m.put(p.key, p.val)\n        }\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (m *hashMapChaining) print() {\n    var builder strings.Builder\n\n    for _, bucket := range m.buckets {\n        builder.WriteString(\"[\")\n        for _, p := range bucket {\n            builder.WriteString(strconv.Itoa(p.key) + \" -> \" + p.val + \" \")\n        }\n        builder.WriteString(\"]\")\n        fmt.Println(builder.String())\n        builder.Reset()\n    }\n}\n
    hash_map_chaining.swift
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    var loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    var extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: [[Pair]] // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: [], count: capacity)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    func hashFunc(key: Int) -> Int {\n        key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    func loadFactor() -> Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket {\n            if pair.key == key {\n                return pair.val\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de nil\n        return nil\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if loadFactor() > loadThres {\n            extend()\n        }\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val\n                return\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        let pair = Pair(key: key, val: val)\n        buckets[index].append(pair)\n        size += 1\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        let bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (pairIndex, pair) in bucket.enumerated() {\n            if pair.key == key {\n                buckets[index].remove(at: pairIndex)\n                size -= 1\n                break\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    func extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = Array(repeating: [], count: capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in bucketsTmp {\n            for pair in bucket {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for bucket in buckets {\n            let res = bucket.map { \"\\($0.key) -> \\($0.val)\" }\n            Swift.print(res)\n        }\n    }\n}\n
    hash_map_chaining.js
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    #size; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio; // \u6269\u5bb9\u500d\u6570\n    #buckets; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key, val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key) {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (let i = 0; i < bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -> ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n
    hash_map_chaining.ts
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n    #size: number; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity: number; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres: number; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio: number; // \u6269\u5bb9\u500d\u6570\n    #buckets: Pair[][]; // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0;\n        this.#capacity = 4;\n        this.#loadThres = 2.0 / 3.0;\n        this.#extendRatio = 2;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key: number): number {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor(): number {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key: number): string | null {\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                return pair.val;\n            }\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key: number, val: string): void {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        const index = this.#hashFunc(key);\n        const bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (const pair of bucket) {\n            if (pair.key === key) {\n                pair.val = val;\n                return;\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        const pair = new Pair(key, val);\n        bucket.push(pair);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key: number): void {\n        const index = this.#hashFunc(key);\n        let bucket = this.#buckets[index];\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (let i = 0; i < bucket.length; i++) {\n            if (bucket[i].key === key) {\n                bucket.splice(i, 1);\n                this.#size--;\n                break;\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend(): void {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const bucket of bucketsTmp) {\n            for (const pair of bucket) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print(): void {\n        for (const bucket of this.#buckets) {\n            let res = [];\n            for (const pair of bucket) {\n                res.push(pair.key + ' -> ' + pair.val);\n            }\n            console.log(res);\n        }\n    }\n}\n
    hash_map_chaining.dart
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining {\n  late int size; // \u952e\u503c\u5bf9\u6570\u91cf\n  late int capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n  late double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n  late int extendRatio; // \u6269\u5bb9\u500d\u6570\n  late List<List<Pair>> buckets; // \u6876\u6570\u7ec4\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  HashMapChaining() {\n    size = 0;\n    capacity = 4;\n    loadThres = 2.0 / 3.0;\n    extendRatio = 2;\n    buckets = List.generate(capacity, (_) => []);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int hashFunc(int key) {\n    return key % capacity;\n  }\n\n  /* \u8d1f\u8f7d\u56e0\u5b50 */\n  double loadFactor() {\n    return size / capacity;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    int index = hashFunc(key);\n    List<Pair> bucket = buckets[index];\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        return pair.val;\n      }\n    }\n    // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n    return null;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor() > loadThres) {\n      extend();\n    }\n    int index = hashFunc(key);\n    List<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\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        pair.val = val;\n        return;\n      }\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n    Pair pair = Pair(key, val);\n    bucket.add(pair);\n    size++;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    int index = hashFunc(key);\n    List<Pair> bucket = buckets[index];\n    // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n    for (Pair pair in bucket) {\n      if (pair.key == key) {\n        bucket.remove(pair);\n        size--;\n        break;\n      }\n    }\n  }\n\n  /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n  void extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    List<List<Pair>> bucketsTmp = buckets;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    capacity *= extendRatio;\n    buckets = List.generate(capacity, (_) => []);\n    size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (List<Pair> bucket in bucketsTmp) {\n      for (Pair pair in bucket) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (List<Pair> bucket in buckets) {\n      List<String> res = [];\n      for (Pair pair in bucket) {\n        res.add(\"${pair.key} -> ${pair.val}\");\n      }\n      print(res);\n    }\n  }\n}\n
    hash_map_chaining.rs
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nstruct HashMapChaining {\n    size: i32,\n    capacity: i32,\n    load_thres: f32,\n    extend_ratio: i32,\n    buckets: Vec<Vec<Pair>>,\n}\n\nimpl HashMapChaining {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new() -> Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![vec![]; 4],\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        key as usize % self.capacity as usize\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fn load_factor(&self) -> f32 {\n        self.size as f32 / self.capacity as f32\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fn remove(&mut self, key: i32) -> Option<String> {\n        let index = self.hash_func(key);\n        let bucket = &mut self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for i in 0..bucket.len() {\n            if bucket[i].key == key {\n                let pair = bucket.remove(i);\n                self.size -= 1;\n                return Some(pair.val);\n            }\n        }\n\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        None\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fn extend(&mut self) {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let buckets_tmp = std::mem::replace(&mut self.buckets, vec![]);\n\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![Vec::new(); self.capacity as usize];\n        self.size = 0;\n\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for bucket in buckets_tmp {\n            for pair in bucket {\n                self.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fn print(&self) {\n        for bucket in &self.buckets {\n            let mut res = Vec::new();\n            for pair in bucket {\n                res.push(format!(\"{} -> {}\", pair.key, pair.val));\n            }\n            println!(\"{:?}\", res);\n        }\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fn put(&mut self, key: i32, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if self.load_factor() > self.load_thres {\n            self.extend();\n        }\n\n        let index = self.hash_func(key);\n        let bucket = &mut self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for pair in bucket {\n            if pair.key == key {\n                pair.val = val.clone();\n                return;\n            }\n        }\n        let bucket = &mut self.buckets[index];\n\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        let pair = Pair {\n            key,\n            val: val.clone(),\n        };\n        bucket.push(pair);\n        self.size += 1;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fn get(&self, key: i32) -> Option<&str> {\n        let index = self.hash_func(key);\n        let bucket = &self.buckets[index];\n\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for pair in bucket {\n            if pair.key == key {\n                return Some(&pair.val);\n            }\n        }\n\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de None\n        None\n    }\n}\n
    hash_map_chaining.c
    /* \u94fe\u8868\u8282\u70b9 */\ntypedef struct Node {\n    Pair *pair;\n    struct Node *next;\n} Node;\n\n/* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\ntypedef struct {\n    int size;         // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;  // \u6269\u5bb9\u500d\u6570\n    Node **buckets;   // \u6876\u6570\u7ec4\n} HashMapChaining;\n\n/* \u6784\u9020\u51fd\u6570 */\nHashMapChaining *newHashMapChaining() {\n    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));\n    hashMap->size = 0;\n    hashMap->capacity = 4;\n    hashMap->loadThres = 2.0 / 3.0;\n    hashMap->extendRatio = 2;\n    hashMap->buckets = (Node **)malloc(hashMap->capacity * sizeof(Node *));\n    for (int i = 0; i < hashMap->capacity; i++) {\n        hashMap->buckets[i] = NULL;\n    }\n    return hashMap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delHashMapChaining(HashMapChaining *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Node *cur = hashMap->buckets[i];\n        while (cur) {\n            Node *tmp = cur;\n            cur = cur->next;\n            free(tmp->pair);\n            free(tmp);\n        }\n    }\n    free(hashMap->buckets);\n    free(hashMap);\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(HashMapChaining *hashMap, int key) {\n    return key % hashMap->capacity;\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor(HashMapChaining *hashMap) {\n    return (double)hashMap->size / (double)hashMap->capacity;\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nchar *get(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    Node *cur = hashMap->buckets[index];\n    while (cur) {\n        if (cur->pair->key == key) {\n            return cur->pair->val;\n        }\n        cur = cur->next;\n    }\n    return \"\"; // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(HashMapChaining *hashMap, int key, const char *val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor(hashMap) > hashMap->loadThres) {\n        extend(hashMap);\n    }\n    int index = hashFunc(hashMap, key);\n    // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n    Node *cur = hashMap->buckets[index];\n    while (cur) {\n        if (cur->pair->key == key) {\n            strcpy(cur->pair->val, val); // \u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n            return;\n        }\n        cur = cur->next;\n    }\n    // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n    Pair *newPair = (Pair *)malloc(sizeof(Pair));\n    newPair->key = key;\n    strcpy(newPair->val, val);\n    Node *newNode = (Node *)malloc(sizeof(Node));\n    newNode->pair = newPair;\n    newNode->next = hashMap->buckets[index];\n    hashMap->buckets[index] = newNode;\n    hashMap->size++;\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend(HashMapChaining *hashMap) {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    int oldCapacity = hashMap->capacity;\n    Node **oldBuckets = hashMap->buckets;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    hashMap->capacity *= hashMap->extendRatio;\n    hashMap->buckets = (Node **)malloc(hashMap->capacity * sizeof(Node *));\n    for (int i = 0; i < hashMap->capacity; i++) {\n        hashMap->buckets[i] = NULL;\n    }\n    hashMap->size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (int i = 0; i < oldCapacity; i++) {\n        Node *cur = oldBuckets[i];\n        while (cur) {\n            put(hashMap, cur->pair->key, cur->pair->val);\n            Node *temp = cur;\n            cur = cur->next;\n            // \u91ca\u653e\u5185\u5b58\n            free(temp->pair);\n            free(temp);\n        }\n    }\n\n    free(oldBuckets);\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(HashMapChaining *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    Node *cur = hashMap->buckets[index];\n    Node *pre = NULL;\n    while (cur) {\n        if (cur->pair->key == key) {\n            // \u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n            if (pre) {\n                pre->next = cur->next;\n            } else {\n                hashMap->buckets[index] = cur->next;\n            }\n            // \u91ca\u653e\u5185\u5b58\n            free(cur->pair);\n            free(cur);\n            hashMap->size--;\n            return;\n        }\n        pre = cur;\n        cur = cur->next;\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(HashMapChaining *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Node *cur = hashMap->buckets[i];\n        printf(\"[\");\n        while (cur) {\n            printf(\"%d -> %s, \", cur->pair->key, cur->pair->val);\n            cur = cur->next;\n        }\n        printf(\"]\\n\");\n    }\n}\n
    hash_map_chaining.kt
    /* \u94fe\u5f0f\u5730\u5740\u54c8\u5e0c\u8868 */\nclass HashMapChaining() {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    val loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    val extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: MutableList<MutableList<Pair>> // \u6876\u6570\u7ec4\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = ArrayList(capacity)\n        for (i in 0..<capacity) {\n            buckets.add(mutableListOf())\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u627e\u5230 key \uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        for (pair in bucket) {\n            if (pair.key == key) return pair.value\n        }\n        // \u82e5\u672a\u627e\u5230 key \uff0c\u5219\u8fd4\u56de null\n        return null\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend()\n        }\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u82e5\u9047\u5230\u6307\u5b9a key \uff0c\u5219\u66f4\u65b0\u5bf9\u5e94 val \u5e76\u8fd4\u56de\n        for (pair in bucket) {\n            if (pair.key == key) {\n                pair.value = value\n                return\n            }\n        }\n        // \u82e5\u65e0\u8be5 key \uff0c\u5219\u5c06\u952e\u503c\u5bf9\u6dfb\u52a0\u81f3\u5c3e\u90e8\n        val pair = Pair(key, value)\n        bucket.add(pair)\n        size++\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        val bucket = buckets[index]\n        // \u904d\u5386\u6876\uff0c\u4ece\u4e2d\u5220\u9664\u952e\u503c\u5bf9\n        for (pair in bucket) {\n            if (pair.key == key) {\n                bucket.remove(pair)\n                size--\n                break\n            }\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fun extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        val bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        // mutablelist \u65e0\u56fa\u5b9a\u5927\u5c0f\n        buckets = mutableListOf()\n        for (i in 0..<capacity) {\n            buckets.add(mutableListOf())\n        }\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (bucket in bucketsTmp) {\n            for (pair in bucket) {\n                put(pair.key, pair.value)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (bucket in buckets) {\n            val res = mutableListOf<String>()\n            for (pair in bucket) {\n                val k = pair.key\n                val v = pair.value\n                res.add(\"$k -> $v\")\n            }\n            println(res)\n        }\n    }\n}\n
    hash_map_chaining.rb
    [class]{HashMapChaining}-[func]{}\n
    hash_map_chaining.zig
    [class]{HashMapChaining}-[func]{}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u5f53\u94fe\u8868\u5f88\u957f\u65f6\uff0c\u67e5\u8be2\u6548\u7387 \\(O(n)\\) \u5f88\u5dee\u3002\u6b64\u65f6\u53ef\u4ee5\u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u201cAVL \u6811\u201d\u6216\u201c\u7ea2\u9ed1\u6811\u201d\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\u548c\u591a\u6b21\u54c8\u5e0c\u7b49\u3002

    \u4e0b\u9762\u4ee5\u7ebf\u6027\u63a2\u6d4b\u4e3a\u4f8b\uff0c\u4ecb\u7ecd\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\u7684\u5de5\u4f5c\u673a\u5236\u3002

    "},{"location":"chapter_hashing/hash_collision/#1","title":"1. \u00a0 \u7ebf\u6027\u63a2\u6d4b","text":"

    \u7ebf\u6027\u63a2\u6d4b\u91c7\u7528\u56fa\u5b9a\u6b65\u957f\u7684\u7ebf\u6027\u641c\u7d22\u6765\u8fdb\u884c\u63a2\u6d4b\uff0c\u5176\u64cd\u4f5c\u65b9\u6cd5\u4e0e\u666e\u901a\u54c8\u5e0c\u8868\u6709\u6240\u4e0d\u540c\u3002

    • \u63d2\u5165\u5143\u7d20\uff1a\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u8ba1\u7b97\u6876\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\u6876\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\u8fdb\u884c\u7ebf\u6027\u904d\u5386\uff0c\u76f4\u5230\u627e\u5230\u5bf9\u5e94\u5143\u7d20\uff0c\u8fd4\u56de value \u5373\u53ef\uff1b\u5982\u679c\u9047\u5230\u7a7a\u6876\uff0c\u8bf4\u660e\u76ee\u6807\u5143\u7d20\u4e0d\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u8fd4\u56de None \u3002

    \u56fe 6-6 \u5c55\u793a\u4e86\u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\uff09\u54c8\u5e0c\u8868\u7684\u952e\u503c\u5bf9\u5206\u5e03\u3002\u6839\u636e\u6b64\u54c8\u5e0c\u51fd\u6570\uff0c\u6700\u540e\u4e24\u4f4d\u76f8\u540c\u7684 key \u90fd\u4f1a\u88ab\u6620\u5c04\u5230\u76f8\u540c\u7684\u6876\u3002\u800c\u901a\u8fc7\u7ebf\u6027\u63a2\u6d4b\uff0c\u5b83\u4eec\u88ab\u4f9d\u6b21\u5b58\u50a8\u5728\u8be5\u6876\u4ee5\u53ca\u4e4b\u4e0b\u7684\u6876\u4e2d\u3002

    \u56fe 6-6 \u00a0 \u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\uff09\u54c8\u5e0c\u8868\u7684\u952e\u503c\u5bf9\u5206\u5e03

    \u7136\u800c\uff0c\u7ebf\u6027\u63a2\u6d4b\u5bb9\u6613\u4ea7\u751f\u201c\u805a\u96c6\u73b0\u8c61\u201d\u3002\u5177\u4f53\u6765\u8bf4\uff0c\u6570\u7ec4\u4e2d\u8fde\u7eed\u88ab\u5360\u7528\u7684\u4f4d\u7f6e\u8d8a\u957f\uff0c\u8fd9\u4e9b\u8fde\u7eed\u4f4d\u7f6e\u53d1\u751f\u54c8\u5e0c\u51b2\u7a81\u7684\u53ef\u80fd\u6027\u8d8a\u5927\uff0c\u4ece\u800c\u8fdb\u4e00\u6b65\u4fc3\u4f7f\u8be5\u4f4d\u7f6e\u7684\u805a\u5806\u751f\u957f\uff0c\u5f62\u6210\u6076\u6027\u5faa\u73af\uff0c\u6700\u7ec8\u5bfc\u81f4\u589e\u5220\u67e5\u6539\u64cd\u4f5c\u6548\u7387\u52a3\u5316\u3002

    \u503c\u5f97\u6ce8\u610f\u7684\u662f\uff0c\u6211\u4eec\u4e0d\u80fd\u5728\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\u4e2d\u76f4\u63a5\u5220\u9664\u5143\u7d20\u3002\u8fd9\u662f\u56e0\u4e3a\u5220\u9664\u5143\u7d20\u4f1a\u5728\u6570\u7ec4\u5185\u4ea7\u751f\u4e00\u4e2a\u7a7a\u6876 None \uff0c\u800c\u5f53\u67e5\u8be2\u5143\u7d20\u65f6\uff0c\u7ebf\u6027\u63a2\u6d4b\u5230\u8be5\u7a7a\u6876\u5c31\u4f1a\u8fd4\u56de\uff0c\u56e0\u6b64\u5728\u8be5\u7a7a\u6876\u4e4b\u4e0b\u7684\u5143\u7d20\u90fd\u65e0\u6cd5\u518d\u88ab\u8bbf\u95ee\u5230\uff0c\u7a0b\u5e8f\u53ef\u80fd\u8bef\u5224\u8fd9\u4e9b\u5143\u7d20\u4e0d\u5b58\u5728\uff0c\u5982\u56fe 6-7 \u6240\u793a\u3002

    \u56fe 6-7 \u00a0 \u5728\u5f00\u653e\u5bfb\u5740\u4e2d\u5220\u9664\u5143\u7d20\u5bfc\u81f4\u7684\u67e5\u8be2\u95ee\u9898

    \u4e3a\u4e86\u89e3\u51b3\u8be5\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u91c7\u7528\u300c\u61d2\u5220\u9664 lazy deletion\u300d\u673a\u5236\uff1a\u5b83\u4e0d\u76f4\u63a5\u4ece\u54c8\u5e0c\u8868\u4e2d\u79fb\u9664\u5143\u7d20\uff0c\u800c\u662f\u5229\u7528\u4e00\u4e2a\u5e38\u91cf TOMBSTONE \u6765\u6807\u8bb0\u8fd9\u4e2a\u6876\u3002\u5728\u8be5\u673a\u5236\u4e0b\uff0cNone \u548c TOMBSTONE \u90fd\u4ee3\u8868\u7a7a\u6876\uff0c\u90fd\u53ef\u4ee5\u653e\u7f6e\u952e\u503c\u5bf9\u3002\u4f46\u4e0d\u540c\u7684\u662f\uff0c\u7ebf\u6027\u63a2\u6d4b\u5230 TOMBSTONE \u65f6\u5e94\u8be5\u7ee7\u7eed\u904d\u5386\uff0c\u56e0\u4e3a\u5176\u4e4b\u4e0b\u53ef\u80fd\u8fd8\u5b58\u5728\u952e\u503c\u5bf9\u3002

    \u7136\u800c\uff0c\u61d2\u5220\u9664\u53ef\u80fd\u4f1a\u52a0\u901f\u54c8\u5e0c\u8868\u7684\u6027\u80fd\u9000\u5316\u3002\u8fd9\u662f\u56e0\u4e3a\u6bcf\u6b21\u5220\u9664\u64cd\u4f5c\u90fd\u4f1a\u4ea7\u751f\u4e00\u4e2a\u5220\u9664\u6807\u8bb0\uff0c\u968f\u7740 TOMBSTONE \u7684\u589e\u52a0\uff0c\u641c\u7d22\u65f6\u95f4\u4e5f\u4f1a\u589e\u52a0\uff0c\u56e0\u4e3a\u7ebf\u6027\u63a2\u6d4b\u53ef\u80fd\u9700\u8981\u8df3\u8fc7\u591a\u4e2a TOMBSTONE \u624d\u80fd\u627e\u5230\u76ee\u6807\u5143\u7d20\u3002

    \u4e3a\u6b64\uff0c\u8003\u8651\u5728\u7ebf\u6027\u63a2\u6d4b\u4e2d\u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a TOMBSTONE \u7684\u7d22\u5f15\uff0c\u5e76\u5c06\u641c\u7d22\u5230\u7684\u76ee\u6807\u5143\u7d20\u4e0e\u8be5 TOMBSTONE \u4ea4\u6362\u4f4d\u7f6e\u3002\u8fd9\u6837\u505a\u7684\u597d\u5904\u662f\u5f53\u6bcf\u6b21\u67e5\u8be2\u6216\u6dfb\u52a0\u5143\u7d20\u65f6\uff0c\u5143\u7d20\u4f1a\u88ab\u79fb\u52a8\u81f3\u8ddd\u79bb\u7406\u60f3\u4f4d\u7f6e\uff08\u63a2\u6d4b\u8d77\u59cb\u70b9\uff09\u66f4\u8fd1\u7684\u6876\uff0c\u4ece\u800c\u4f18\u5316\u67e5\u8be2\u6548\u7387\u3002

    \u4ee5\u4e0b\u4ee3\u7801\u5b9e\u73b0\u4e86\u4e00\u4e2a\u5305\u542b\u61d2\u5220\u9664\u7684\u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\uff09\u54c8\u5e0c\u8868\u3002\u4e3a\u4e86\u66f4\u52a0\u5145\u5206\u5730\u4f7f\u7528\u54c8\u5e0c\u8868\u7684\u7a7a\u95f4\uff0c\u6211\u4eec\u5c06\u54c8\u5e0c\u8868\u770b\u4f5c\u4e00\u4e2a\u201c\u73af\u5f62\u6570\u7ec4\u201d\uff0c\u5f53\u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u65f6\uff0c\u56de\u5230\u5934\u90e8\u7ee7\u7eed\u904d\u5386\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map_open_addressing.py
    class HashMapOpenAddressing:\n    \"\"\"\u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.size = 0  # \u952e\u503c\u5bf9\u6570\u91cf\n        self.capacity = 4  # \u54c8\u5e0c\u8868\u5bb9\u91cf\n        self.load_thres = 2.0 / 3.0  # \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        self.extend_ratio = 2  # \u6269\u5bb9\u500d\u6570\n        self.buckets: list[Pair | None] = [None] * self.capacity  # \u6876\u6570\u7ec4\n        self.TOMBSTONE = Pair(-1, \"-1\")  # \u5220\u9664\u6807\u8bb0\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        return key % self.capacity\n\n    def load_factor(self) -> float:\n        \"\"\"\u8d1f\u8f7d\u56e0\u5b50\"\"\"\n        return self.size / self.capacity\n\n    def find_bucket(self, key: int) -> int:\n        \"\"\"\u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\"\"\"\n        index = self.hash_func(key)\n        first_tombstone = -1\n        # \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while self.buckets[index] is not None:\n            # \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if self.buckets[index].key == key:\n                # \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if first_tombstone != -1:\n                    self.buckets[first_tombstone] = self.buckets[index]\n                    self.buckets[index] = self.TOMBSTONE\n                    return first_tombstone  # \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                return index  # \u8fd4\u56de\u6876\u7d22\u5f15\n            # \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE:\n                first_tombstone = index\n            # \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % self.capacity\n        # \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return index if first_tombstone == -1 else first_tombstone\n\n    def get(self, key: int) -> str:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            return self.buckets[index].val\n        # \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de None\n        return None\n\n    def 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\n        if self.load_factor() > self.load_thres:\n            self.extend()\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index].val = val\n            return\n        # \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        self.buckets[index] = Pair(key, val)\n        self.size += 1\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        # \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        index = self.find_bucket(key)\n        # \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if self.buckets[index] not in [None, self.TOMBSTONE]:\n            self.buckets[index] = self.TOMBSTONE\n            self.size -= 1\n\n    def extend(self):\n        \"\"\"\u6269\u5bb9\u54c8\u5e0c\u8868\"\"\"\n        # \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        buckets_tmp = self.buckets\n        # \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio\n        self.buckets = [None] * self.capacity\n        self.size = 0\n        # \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in buckets_tmp:\n            if pair not in [None, self.TOMBSTONE]:\n                self.put(pair.key, pair.val)\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for pair in self.buckets:\n            if pair is None:\n                print(\"None\")\n            elif pair is self.TOMBSTONE:\n                print(\"TOMBSTONE\")\n            else:\n                print(pair.key, \"->\", pair.val)\n
    hash_map_open_addressing.cpp
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n  private:\n    int size;                             // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity = 4;                     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    const double loadThres = 2.0 / 3.0;     // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    const int extendRatio = 2;            // \u6269\u5bb9\u500d\u6570\n    vector<Pair *> buckets;               // \u6876\u6570\u7ec4\n    Pair *TOMBSTONE = new Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    HashMapOpenAddressing() : size(0), buckets(capacity, nullptr) {\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~HashMapOpenAddressing() {\n        for (Pair *pair : buckets) {\n            if (pair != nullptr && pair != TOMBSTONE) {\n                delete pair;\n            }\n        }\n        delete TOMBSTONE;\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double loadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != nullptr) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index]->key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            return buckets[index]->val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n        return \"\";\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            buckets[index]->val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != nullptr && buckets[index] != TOMBSTONE) {\n            delete buckets[index];\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        vector<Pair *> bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = vector<Pair *>(capacity, nullptr);\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (Pair *pair : bucketsTmp) {\n            if (pair != nullptr && pair != TOMBSTONE) {\n                put(pair->key, pair->val);\n                delete pair;\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (Pair *pair : buckets) {\n            if (pair == nullptr) {\n                cout << \"nullptr\" << endl;\n            } else if (pair == TOMBSTONE) {\n                cout << \"TOMBSTONE\" << endl;\n            } else {\n                cout << pair->key << \" -> \" << pair->val << endl;\n            }\n        }\n    }\n};\n
    hash_map_open_addressing.java
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    private int capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private final double loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private final int extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n    private Pair[] buckets; // \u6876\u6570\u7ec4\n    private final Pair TOMBSTONE = new Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private int hashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    private double loadFactor() {\n        return (double) size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    private int findBucket(int key) {\n        int index = hashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index].key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public String get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void put(int key, String val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    private void extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        Pair[] bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (Pair pair : bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void print() {\n        for (Pair pair : buckets) {\n            if (pair == null) {\n                System.out.println(\"null\");\n            } else if (pair == TOMBSTONE) {\n                System.out.println(\"TOMBSTONE\");\n            } else {\n                System.out.println(pair.key + \" -> \" + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.cs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    int size; // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n    Pair[] buckets; // \u6876\u6570\u7ec4\n    Pair TOMBSTONE = new(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public HashMapOpenAddressing() {\n        size = 0;\n        buckets = new Pair[capacity];\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        return key % capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    double LoadFactor() {\n        return (double)size / capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    int FindBucket(int key) {\n        int index = HashFunc(key);\n        int firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index].key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index];\n                    buckets[index] = TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (LoadFactor() > loadThres) {\n            Extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = new Pair(key, val);\n        size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        int index = FindBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE;\n            size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    void Extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        Pair[] bucketsTmp = buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio;\n        buckets = new Pair[capacity];\n        size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        foreach (Pair pair in bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                Put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (Pair pair in buckets) {\n            if (pair == null) {\n                Console.WriteLine(\"null\");\n            } else if (pair == TOMBSTONE) {\n                Console.WriteLine(\"TOMBSTONE\");\n            } else {\n                Console.WriteLine(pair.key + \" -> \" + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.go
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\ntype hashMapOpenAddressing struct {\n    size        int     // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity    int     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    loadThres   float64 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extendRatio int     // \u6269\u5bb9\u500d\u6570\n    buckets     []*pair // \u6876\u6570\u7ec4\n    TOMBSTONE   *pair   // \u5220\u9664\u6807\u8bb0\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newHashMapOpenAddressing() *hashMapOpenAddressing {\n    return &hashMapOpenAddressing{\n        size:        0,\n        capacity:    4,\n        loadThres:   2.0 / 3.0,\n        extendRatio: 2,\n        buckets:     make([]*pair, 4),\n        TOMBSTONE:   &pair{-1, \"-1\"},\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (h *hashMapOpenAddressing) hashFunc(key int) int {\n    return key % h.capacity // \u6839\u636e\u952e\u8ba1\u7b97\u54c8\u5e0c\u503c\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\nfunc (h *hashMapOpenAddressing) loadFactor() float64 {\n    return float64(h.size) / float64(h.capacity) // \u8ba1\u7b97\u5f53\u524d\u8d1f\u8f7d\u56e0\u5b50\n}\n\n/* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\nfunc (h *hashMapOpenAddressing) findBucket(key int) int {\n    index := h.hashFunc(key) // \u83b7\u53d6\u521d\u59cb\u7d22\u5f15\n    firstTombstone := -1     // \u8bb0\u5f55\u9047\u5230\u7684\u7b2c\u4e00\u4e2aTOMBSTONE\u7684\u4f4d\u7f6e\n    for h.buckets[index] != nil {\n        if h.buckets[index].key == key {\n            if firstTombstone != -1 {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                h.buckets[firstTombstone] = h.buckets[index]\n                h.buckets[index] = h.TOMBSTONE\n                return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n            }\n            return index // \u8fd4\u56de\u627e\u5230\u7684\u7d22\u5f15\n        }\n        if firstTombstone == -1 && h.buckets[index] == h.TOMBSTONE {\n            firstTombstone = index // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\u7684\u4f4d\u7f6e\n        }\n        index = (index + 1) % h.capacity // \u7ebf\u6027\u63a2\u6d4b\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    if firstTombstone != -1 {\n        return firstTombstone\n    }\n    return index\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) get(key int) string {\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {\n        return h.buckets[index].val // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    }\n    return \"\" // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de \"\"\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) put(key int, val string) {\n    if h.loadFactor() > h.loadThres {\n        h.extend() // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    }\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {\n        h.buckets[index] = &pair{key, val} // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        h.size++\n    } else {\n        h.buckets[index].val = val // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val\n    }\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (h *hashMapOpenAddressing) remove(key int) {\n    index := h.findBucket(key) // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {\n        h.buckets[index] = h.TOMBSTONE // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        h.size--\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nfunc (h *hashMapOpenAddressing) extend() {\n    oldBuckets := h.buckets               // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    h.capacity *= h.extendRatio           // \u66f4\u65b0\u5bb9\u91cf\n    h.buckets = make([]*pair, h.capacity) // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    h.size = 0                            // \u91cd\u7f6e\u5927\u5c0f\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for _, pair := range oldBuckets {\n        if pair != nil && pair != h.TOMBSTONE {\n            h.put(pair.key, pair.val)\n        }\n    }\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (h *hashMapOpenAddressing) print() {\n    for _, pair := range h.buckets {\n        if pair == nil {\n            fmt.Println(\"nil\")\n        } else if pair == h.TOMBSTONE {\n            fmt.Println(\"TOMBSTONE\")\n        } else {\n            fmt.Printf(\"%d -> %s\\n\", pair.key, pair.val)\n        }\n    }\n}\n
    hash_map_open_addressing.swift
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    var size: Int // \u952e\u503c\u5bf9\u6570\u91cf\n    var capacity: Int // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    var loadThres: Double // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    var extendRatio: Int // \u6269\u5bb9\u500d\u6570\n    var buckets: [Pair?] // \u6876\u6570\u7ec4\n    var TOMBSTONE: Pair // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init() {\n        size = 0\n        capacity = 4\n        loadThres = 2.0 / 3.0\n        extendRatio = 2\n        buckets = Array(repeating: nil, count: capacity)\n        TOMBSTONE = Pair(key: -1, val: \"-1\")\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    func hashFunc(key: Int) -> Int {\n        key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    func loadFactor() -> Double {\n        Double(size) / Double(capacity)\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    func findBucket(key: Int) -> Int {\n        var index = hashFunc(key: key)\n        var firstTombstone = -1\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while buckets[index] != nil {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if buckets[index]!.key == key {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if firstTombstone != -1 {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if firstTombstone == -1 && buckets[index] == TOMBSTONE {\n                firstTombstone = index\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone == -1 ? index : firstTombstone\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            return buckets[index]!.val\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return nil\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if loadFactor() > loadThres {\n            extend()\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index]!.val = val\n            return\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = Pair(key: key, val: val)\n        size += 1\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = findBucket(key: key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if buckets[index] != nil, buckets[index] != TOMBSTONE {\n            buckets[index] = TOMBSTONE\n            size -= 1\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    func extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = Array(repeating: nil, count: capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in bucketsTmp {\n            if let pair, pair != TOMBSTONE {\n                put(key: pair.key, val: pair.val)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for pair in buckets {\n            if pair == nil {\n                Swift.print(\"null\")\n            } else if pair == TOMBSTONE {\n                Swift.print(\"TOMBSTONE\")\n            } else {\n                Swift.print(\"\\(pair!.key) -> \\(pair!.val)\")\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.js
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    #size; // \u952e\u503c\u5bf9\u6570\u91cf\n    #capacity; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    #loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    #extendRatio; // \u6269\u5bb9\u500d\u6570\n    #buckets; // \u6876\u6570\u7ec4\n    #TOMBSTONE; // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.#size = 0; // \u952e\u503c\u5bf9\u6570\u91cf\n        this.#capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n        this.#loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        this.#extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n        this.#buckets = Array(this.#capacity).fill(null); // \u6876\u6570\u7ec4\n        this.#TOMBSTONE = new Pair(-1, '-1'); // \u5220\u9664\u6807\u8bb0\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % this.#capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    #loadFactor() {\n        return this.#size / this.#capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    #findBucket(key) {\n        let index = this.#hashFunc(key);\n        let firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (this.#buckets[index] !== null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (this.#buckets[index].key === key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone !== -1) {\n                    this.#buckets[firstTombstone] = this.#buckets[index];\n                    this.#buckets[index] = this.#TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (\n                firstTombstone === -1 &&\n                this.#buckets[index] === this.#TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % this.#capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            return this.#buckets[index].val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key, val) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.#loadFactor() > this.#loadThres) {\n            this.#extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index].val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        this.#buckets[index] = new Pair(key, val);\n        this.#size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.#findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (\n            this.#buckets[index] !== null &&\n            this.#buckets[index] !== this.#TOMBSTONE\n        ) {\n            this.#buckets[index] = this.#TOMBSTONE;\n            this.#size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    #extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.#buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.#capacity *= this.#extendRatio;\n        this.#buckets = Array(this.#capacity).fill(null);\n        this.#size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const pair of bucketsTmp) {\n            if (pair !== null && pair !== this.#TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        for (const pair of this.#buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.#TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -> ' + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.ts
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private size: number; // \u952e\u503c\u5bf9\u6570\u91cf\n    private capacity: number; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private loadThres: number; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private extendRatio: number; // \u6269\u5bb9\u500d\u6570\n    private buckets: Array<Pair | null>; // \u6876\u6570\u7ec4\n    private TOMBSTONE: Pair; // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor() {\n        this.size = 0; // \u952e\u503c\u5bf9\u6570\u91cf\n        this.capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n        this.loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n        this.extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n        this.buckets = Array(this.capacity).fill(null); // \u6876\u6570\u7ec4\n        this.TOMBSTONE = new Pair(-1, '-1'); // \u5220\u9664\u6807\u8bb0\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private hashFunc(key: number): number {\n        return key % this.capacity;\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    private loadFactor(): number {\n        return this.size / this.capacity;\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    private findBucket(key: number): number {\n        let index = this.hashFunc(key);\n        let firstTombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (this.buckets[index] !== null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (this.buckets[index]!.key === key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone !== -1) {\n                    this.buckets[firstTombstone] = this.buckets[index];\n                    this.buckets[index] = this.TOMBSTONE;\n                    return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (\n                firstTombstone === -1 &&\n                this.buckets[index] === this.TOMBSTONE\n            ) {\n                firstTombstone = index;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % this.capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return firstTombstone === -1 ? index : firstTombstone;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key: number): string | null {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            return this.buckets[index]!.val;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    put(key: number, val: string): void {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (this.loadFactor() > this.loadThres) {\n            this.extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index]!.val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        this.buckets[index] = new Pair(key, val);\n        this.size++;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    remove(key: number): void {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        const index = this.findBucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (\n            this.buckets[index] !== null &&\n            this.buckets[index] !== this.TOMBSTONE\n        ) {\n            this.buckets[index] = this.TOMBSTONE;\n            this.size--;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    private extend(): void {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        const bucketsTmp = this.buckets;\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        this.capacity *= this.extendRatio;\n        this.buckets = Array(this.capacity).fill(null);\n        this.size = 0;\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (const pair of bucketsTmp) {\n            if (pair !== null && pair !== this.TOMBSTONE) {\n                this.put(pair.key, pair.val);\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print(): void {\n        for (const pair of this.buckets) {\n            if (pair === null) {\n                console.log('null');\n            } else if (pair === this.TOMBSTONE) {\n                console.log('TOMBSTONE');\n            } else {\n                console.log(pair.key + ' -> ' + pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.dart
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n  late int _size; // \u952e\u503c\u5bf9\u6570\u91cf\n  int _capacity = 4; // \u54c8\u5e0c\u8868\u5bb9\u91cf\n  double _loadThres = 2.0 / 3.0; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n  int _extendRatio = 2; // \u6269\u5bb9\u500d\u6570\n  late List<Pair?> _buckets; // \u6876\u6570\u7ec4\n  Pair _TOMBSTONE = Pair(-1, \"-1\"); // \u5220\u9664\u6807\u8bb0\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  HashMapOpenAddressing() {\n    _size = 0;\n    _buckets = List.generate(_capacity, (index) => null);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int hashFunc(int key) {\n    return key % _capacity;\n  }\n\n  /* \u8d1f\u8f7d\u56e0\u5b50 */\n  double loadFactor() {\n    return _size / _capacity;\n  }\n\n  /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n  int findBucket(int key) {\n    int index = hashFunc(key);\n    int firstTombstone = -1;\n    // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n    while (_buckets[index] != null) {\n      // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n      if (_buckets[index]!.key == key) {\n        // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n        if (firstTombstone != -1) {\n          _buckets[firstTombstone] = _buckets[index];\n          _buckets[index] = _TOMBSTONE;\n          return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n        }\n        return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n      }\n      // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n      if (firstTombstone == -1 && _buckets[index] == _TOMBSTONE) {\n        firstTombstone = index;\n      }\n      // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n      index = (index + 1) % _capacity;\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    return firstTombstone == -1 ? index : firstTombstone;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      return _buckets[index]!.val;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n    return null;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor() > _loadThres) {\n      extend();\n    }\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      _buckets[index]!.val = val;\n      return;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n    _buckets[index] = new Pair(key, val);\n    _size++;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {\n      _buckets[index] = _TOMBSTONE;\n      _size--;\n    }\n  }\n\n  /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n  void extend() {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    List<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\n    for (Pair? pair in bucketsTmp) {\n      if (pair != null && pair != _TOMBSTONE) {\n        put(pair.key, pair.val);\n      }\n    }\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (Pair? pair in _buckets) {\n      if (pair == null) {\n        print(\"null\");\n      } else if (pair == _TOMBSTONE) {\n        print(\"TOMBSTONE\");\n      } else {\n        print(\"${pair.key} -> ${pair.val}\");\n      }\n    }\n  }\n}\n
    hash_map_open_addressing.rs
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nstruct HashMapOpenAddressing {\n    size: usize,                // \u952e\u503c\u5bf9\u6570\u91cf\n    capacity: usize,            // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    load_thres: f64,            // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    extend_ratio: usize,        // \u6269\u5bb9\u500d\u6570\n    buckets: Vec<Option<Pair>>, // \u6876\u6570\u7ec4\n    TOMBSTONE: Option<Pair>,    // \u5220\u9664\u6807\u8bb0\n}\n\nimpl HashMapOpenAddressing {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new() -> Self {\n        Self {\n            size: 0,\n            capacity: 4,\n            load_thres: 2.0 / 3.0,\n            extend_ratio: 2,\n            buckets: vec![None; 4],\n            TOMBSTONE: Some(Pair {\n                key: -1,\n                val: \"-1\".to_string(),\n            }),\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        (key % self.capacity as i32) as usize\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fn load_factor(&self) -> f64 {\n        self.size as f64 / self.capacity as f64\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    fn find_bucket(&mut self, key: i32) -> usize {\n        let mut index = self.hash_func(key);\n        let mut first_tombstone = -1;\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while self.buckets[index].is_some() {\n            // \u82e5\u9047\u5230 key\uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if self.buckets[index].as_ref().unwrap().key == key {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u5efa\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\n                if first_tombstone != -1 {\n                    self.buckets[first_tombstone as usize] = self.buckets[index].take();\n                    self.buckets[index] = self.TOMBSTONE.clone();\n                    return first_tombstone as usize; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if first_tombstone == -1 && self.buckets[index] == self.TOMBSTONE {\n                first_tombstone = index as i32;\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % self.capacity;\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        if first_tombstone == -1 {\n            index\n        } else {\n            first_tombstone as usize\n        }\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fn get(&mut self, key: i32) -> Option<&str> {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            return self.buckets[index].as_ref().map(|pair| &pair.val as &str);\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        None\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fn put(&mut self, key: i32, val: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if self.load_factor() > self.load_thres {\n            self.extend();\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index].as_mut().unwrap().val = val;\n            return;\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        self.buckets[index] = Some(Pair { key, val });\n        self.size += 1;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fn remove(&mut self, key: i32) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        let index = self.find_bucket(key);\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if self.buckets[index].is_some() && self.buckets[index] != self.TOMBSTONE {\n            self.buckets[index] = self.TOMBSTONE.clone();\n            self.size -= 1;\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fn extend(&mut self) {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        let buckets_tmp = self.buckets.clone();\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        self.capacity *= self.extend_ratio;\n        self.buckets = vec![None; self.capacity];\n        self.size = 0;\n\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for pair in buckets_tmp {\n            if pair.is_none() || pair == self.TOMBSTONE {\n                continue;\n            }\n            let pair = pair.unwrap();\n\n            self.put(pair.key, pair.val);\n        }\n    }\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fn print(&self) {\n        for pair in &self.buckets {\n            if pair.is_none() {\n                println!(\"null\");\n            } else if pair == &self.TOMBSTONE {\n                println!(\"TOMBSTONE\");\n            } else {\n                let pair = pair.as_ref().unwrap();\n                println!(\"{} -> {}\", pair.key, pair.val);\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.c
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\ntypedef struct {\n    int size;         // \u952e\u503c\u5bf9\u6570\u91cf\n    int capacity;     // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    double loadThres; // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    int extendRatio;  // \u6269\u5bb9\u500d\u6570\n    Pair **buckets;   // \u6876\u6570\u7ec4\n    Pair *TOMBSTONE;  // \u5220\u9664\u6807\u8bb0\n} HashMapOpenAddressing;\n\n/* \u6784\u9020\u51fd\u6570 */\nHashMapOpenAddressing *newHashMapOpenAddressing() {\n    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));\n    hashMap->size = 0;\n    hashMap->capacity = 4;\n    hashMap->loadThres = 2.0 / 3.0;\n    hashMap->extendRatio = 2;\n    hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);\n    hashMap->TOMBSTONE = (Pair *)malloc(sizeof(Pair));\n    hashMap->TOMBSTONE->key = -1;\n    hashMap->TOMBSTONE->val = \"-1\";\n\n    return hashMap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Pair *pair = hashMap->buckets[i];\n        if (pair != NULL && pair != hashMap->TOMBSTONE) {\n            free(pair->val);\n            free(pair);\n        }\n    }\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nint hashFunc(HashMapOpenAddressing *hashMap, int key) {\n    return key % hashMap->capacity;\n}\n\n/* \u8d1f\u8f7d\u56e0\u5b50 */\ndouble loadFactor(HashMapOpenAddressing *hashMap) {\n    return (double)hashMap->size / (double)hashMap->capacity;\n}\n\n/* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\nint findBucket(HashMapOpenAddressing *hashMap, int key) {\n    int index = hashFunc(hashMap, key);\n    int firstTombstone = -1;\n    // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n    while (hashMap->buckets[index] != NULL) {\n        // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        if (hashMap->buckets[index]->key == key) {\n            // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n            if (firstTombstone != -1) {\n                hashMap->buckets[firstTombstone] = hashMap->buckets[index];\n                hashMap->buckets[index] = hashMap->TOMBSTONE;\n                return firstTombstone; // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n            }\n            return index; // \u8fd4\u56de\u6876\u7d22\u5f15\n        }\n        // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n        if (firstTombstone == -1 && hashMap->buckets[index] == hashMap->TOMBSTONE) {\n            firstTombstone = index;\n        }\n        // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n        index = (index + 1) % hashMap->capacity;\n    }\n    // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n    return firstTombstone == -1 ? index : firstTombstone;\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nchar *get(HashMapOpenAddressing *hashMap, int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        return hashMap->buckets[index]->val;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u7a7a\u5b57\u7b26\u4e32\n    return \"\";\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(HashMapOpenAddressing *hashMap, int key, char *val) {\n    // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n    if (loadFactor(hashMap) > hashMap->loadThres) {\n        extend(hashMap);\n    }\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        free(hashMap->buckets[index]->val);\n        hashMap->buckets[index]->val = (char *)malloc(sizeof(strlen(val) + 1));\n        strcpy(hashMap->buckets[index]->val, val);\n        hashMap->buckets[index]->val[strlen(val)] = '\\0';\n        return;\n    }\n    // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n    Pair *pair = (Pair *)malloc(sizeof(Pair));\n    pair->key = key;\n    pair->val = (char *)malloc(sizeof(strlen(val) + 1));\n    strcpy(pair->val, val);\n    pair->val[strlen(val)] = '\\0';\n\n    hashMap->buckets[index] = pair;\n    hashMap->size++;\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(HashMapOpenAddressing *hashMap, int key) {\n    // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n    int index = findBucket(hashMap, key);\n    // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n    if (hashMap->buckets[index] != NULL && hashMap->buckets[index] != hashMap->TOMBSTONE) {\n        Pair *pair = hashMap->buckets[index];\n        free(pair->val);\n        free(pair);\n        hashMap->buckets[index] = hashMap->TOMBSTONE;\n        hashMap->size--;\n    }\n}\n\n/* \u6269\u5bb9\u54c8\u5e0c\u8868 */\nvoid extend(HashMapOpenAddressing *hashMap) {\n    // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n    Pair **bucketsTmp = hashMap->buckets;\n    int oldCapacity = hashMap->capacity;\n    // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n    hashMap->capacity *= hashMap->extendRatio;\n    hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);\n    hashMap->size = 0;\n    // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n    for (int i = 0; i < oldCapacity; i++) {\n        Pair *pair = bucketsTmp[i];\n        if (pair != NULL && pair != hashMap->TOMBSTONE) {\n            put(hashMap, pair->key, pair->val);\n            free(pair->val);\n            free(pair);\n        }\n    }\n    free(bucketsTmp);\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(HashMapOpenAddressing *hashMap) {\n    for (int i = 0; i < hashMap->capacity; i++) {\n        Pair *pair = hashMap->buckets[i];\n        if (pair == NULL) {\n            printf(\"NULL\\n\");\n        } else if (pair == hashMap->TOMBSTONE) {\n            printf(\"TOMBSTONE\\n\");\n        } else {\n            printf(\"%d -> %s\\n\", pair->key, pair->val);\n        }\n    }\n}\n
    hash_map_open_addressing.kt
    /* \u5f00\u653e\u5bfb\u5740\u54c8\u5e0c\u8868 */\nclass HashMapOpenAddressing {\n    private var size: Int = 0 // \u952e\u503c\u5bf9\u6570\u91cf\n    private var capacity = 4 // \u54c8\u5e0c\u8868\u5bb9\u91cf\n    private val loadThres: Double = 2.0 / 3.0 // \u89e6\u53d1\u6269\u5bb9\u7684\u8d1f\u8f7d\u56e0\u5b50\u9608\u503c\n    private val extendRatio = 2 // \u6269\u5bb9\u500d\u6570\n    private var buckets: Array<Pair?> // \u6876\u6570\u7ec4\n    private val TOMBSTONE = Pair(-1, \"-1\") // \u5220\u9664\u6807\u8bb0\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init {\n        buckets = arrayOfNulls(capacity)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        return key % capacity\n    }\n\n    /* \u8d1f\u8f7d\u56e0\u5b50 */\n    fun loadFactor(): Double {\n        return (size / capacity).toDouble()\n    }\n\n    /* \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15 */\n    fun findBucket(key: Int): Int {\n        var index = hashFunc(key)\n        var firstTombstone = -1\n        // \u7ebf\u6027\u63a2\u6d4b\uff0c\u5f53\u9047\u5230\u7a7a\u6876\u65f6\u8df3\u51fa\n        while (buckets[index] != null) {\n            // \u82e5\u9047\u5230 key \uff0c\u8fd4\u56de\u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n            if (buckets[index]?.key == key) {\n                // \u82e5\u4e4b\u524d\u9047\u5230\u4e86\u5220\u9664\u6807\u8bb0\uff0c\u5219\u5c06\u952e\u503c\u5bf9\u79fb\u52a8\u81f3\u8be5\u7d22\u5f15\u5904\n                if (firstTombstone != -1) {\n                    buckets[firstTombstone] = buckets[index]\n                    buckets[index] = TOMBSTONE\n                    return firstTombstone // \u8fd4\u56de\u79fb\u52a8\u540e\u7684\u6876\u7d22\u5f15\n                }\n                return index // \u8fd4\u56de\u6876\u7d22\u5f15\n            }\n            // \u8bb0\u5f55\u9047\u5230\u7684\u9996\u4e2a\u5220\u9664\u6807\u8bb0\n            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {\n                firstTombstone = index\n            }\n            // \u8ba1\u7b97\u6876\u7d22\u5f15\uff0c\u8d8a\u8fc7\u5c3e\u90e8\u5219\u8fd4\u56de\u5934\u90e8\n            index = (index + 1) % capacity\n        }\n        // \u82e5 key \u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de\u6dfb\u52a0\u70b9\u7684\u7d22\u5f15\n        return if (firstTombstone == -1) index else firstTombstone\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8fd4\u56de\u5bf9\u5e94 val\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            return buckets[index]?.value\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u8fd4\u56de null\n        return null\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        // \u5f53\u8d1f\u8f7d\u56e0\u5b50\u8d85\u8fc7\u9608\u503c\u65f6\uff0c\u6267\u884c\u6269\u5bb9\n        if (loadFactor() > loadThres) {\n            extend()\n        }\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u8986\u76d6 val \u5e76\u8fd4\u56de\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index]!!.value = value\n            return\n        }\n        // \u82e5\u952e\u503c\u5bf9\u4e0d\u5b58\u5728\uff0c\u5219\u6dfb\u52a0\u8be5\u952e\u503c\u5bf9\n        buckets[index] = Pair(key, value)\n        size++\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        // \u641c\u7d22 key \u5bf9\u5e94\u7684\u6876\u7d22\u5f15\n        val index = findBucket(key)\n        // \u82e5\u627e\u5230\u952e\u503c\u5bf9\uff0c\u5219\u7528\u5220\u9664\u6807\u8bb0\u8986\u76d6\u5b83\n        if (buckets[index] != null && buckets[index] != TOMBSTONE) {\n            buckets[index] = TOMBSTONE\n            size--\n        }\n    }\n\n    /* \u6269\u5bb9\u54c8\u5e0c\u8868 */\n    fun extend() {\n        // \u6682\u5b58\u539f\u54c8\u5e0c\u8868\n        val bucketsTmp = buckets\n        // \u521d\u59cb\u5316\u6269\u5bb9\u540e\u7684\u65b0\u54c8\u5e0c\u8868\n        capacity *= extendRatio\n        buckets = arrayOfNulls(capacity)\n        size = 0\n        // \u5c06\u952e\u503c\u5bf9\u4ece\u539f\u54c8\u5e0c\u8868\u642c\u8fd0\u81f3\u65b0\u54c8\u5e0c\u8868\n        for (pair in bucketsTmp) {\n            if (pair != null && pair != TOMBSTONE) {\n                put(pair.key, pair.value)\n            }\n        }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (pair in buckets) {\n            if (pair == null) {\n                println(\"null\")\n            } else if (pair == TOMBSTONE) {\n                println(\"TOMESTOME\")\n            } else {\n                println(\"${pair.key} -> ${pair.value}\")\n            }\n        }\n    }\n}\n
    hash_map_open_addressing.rb
    [class]{HashMapOpenAddressing}-[func]{}\n
    hash_map_open_addressing.zig
    [class]{HashMapOpenAddressing}-[func]{}\n
    "},{"location":"chapter_hashing/hash_collision/#2","title":"2. \u00a0 \u5e73\u65b9\u63a2\u6d4b","text":"

    \u5e73\u65b9\u63a2\u6d4b\u4e0e\u7ebf\u6027\u63a2\u6d4b\u7c7b\u4f3c\uff0c\u90fd\u662f\u5f00\u653e\u5bfb\u5740\u7684\u5e38\u89c1\u7b56\u7565\u4e4b\u4e00\u3002\u5f53\u53d1\u751f\u51b2\u7a81\u65f6\uff0c\u5e73\u65b9\u63a2\u6d4b\u4e0d\u662f\u7b80\u5355\u5730\u8df3\u8fc7\u4e00\u4e2a\u56fa\u5b9a\u7684\u6b65\u6570\uff0c\u800c\u662f\u8df3\u8fc7\u201c\u63a2\u6d4b\u6b21\u6570\u7684\u5e73\u65b9\u201d\u7684\u6b65\u6570\uff0c\u5373 \\(1, 4, 9, \\dots\\) \u6b65\u3002

    \u5e73\u65b9\u63a2\u6d4b\u4e3b\u8981\u5177\u6709\u4ee5\u4e0b\u4f18\u52bf\u3002

    • \u5e73\u65b9\u63a2\u6d4b\u901a\u8fc7\u8df3\u8fc7\u63a2\u6d4b\u6b21\u6570\u5e73\u65b9\u7684\u8ddd\u79bb\uff0c\u8bd5\u56fe\u7f13\u89e3\u7ebf\u6027\u63a2\u6d4b\u7684\u805a\u96c6\u6548\u5e94\u3002
    • \u5e73\u65b9\u63a2\u6d4b\u4f1a\u8df3\u8fc7\u66f4\u5927\u7684\u8ddd\u79bb\u6765\u5bfb\u627e\u7a7a\u4f4d\u7f6e\uff0c\u6709\u52a9\u4e8e\u6570\u636e\u5206\u5e03\u5f97\u66f4\u52a0\u5747\u5300\u3002

    \u7136\u800c\uff0c\u5e73\u65b9\u63a2\u6d4b\u5e76\u4e0d\u662f\u5b8c\u7f8e\u7684\u3002

    • \u4ecd\u7136\u5b58\u5728\u805a\u96c6\u73b0\u8c61\uff0c\u5373\u67d0\u4e9b\u4f4d\u7f6e\u6bd4\u5176\u4ed6\u4f4d\u7f6e\u66f4\u5bb9\u6613\u88ab\u5360\u7528\u3002
    • \u7531\u4e8e\u5e73\u65b9\u7684\u589e\u957f\uff0c\u5e73\u65b9\u63a2\u6d4b\u53ef\u80fd\u4e0d\u4f1a\u63a2\u6d4b\u6574\u4e2a\u54c8\u5e0c\u8868\uff0c\u8fd9\u610f\u5473\u7740\u5373\u4f7f\u54c8\u5e0c\u8868\u4e2d\u6709\u7a7a\u6876\uff0c\u5e73\u65b9\u63a2\u6d4b\u4e5f\u53ef\u80fd\u65e0\u6cd5\u8bbf\u95ee\u5230\u5b83\u3002
    "},{"location":"chapter_hashing/hash_collision/#3","title":"3. \u00a0 \u591a\u6b21\u54c8\u5e0c","text":"

    \u987e\u540d\u601d\u4e49\uff0c\u591a\u6b21\u54c8\u5e0c\u65b9\u6cd5\u4f7f\u7528\u591a\u4e2a\u54c8\u5e0c\u51fd\u6570 \\(f_1(x)\\)\u3001\\(f_2(x)\\)\u3001\\(f_3(x)\\)\u3001\\(\\dots\\) \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\u82e5\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 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\u5e26\u6765\u989d\u5916\u7684\u8ba1\u7b97\u91cf\u3002

    Tip

    \u8bf7\u6ce8\u610f\uff0c\u5f00\u653e\u5bfb\u5740\uff08\u7ebf\u6027\u63a2\u6d4b\u3001\u5e73\u65b9\u63a2\u6d4b\u548c\u591a\u6b21\u54c8\u5e0c\uff09\u54c8\u5e0c\u8868\u90fd\u5b58\u5728\u201c\u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u201d\u7684\u95ee\u9898\u3002

    "},{"location":"chapter_hashing/hash_collision/#623","title":"6.2.3 \u00a0 \u7f16\u7a0b\u8bed\u8a00\u7684\u9009\u62e9","text":"

    \u5404\u79cd\u7f16\u7a0b\u8bed\u8a00\u91c7\u53d6\u4e86\u4e0d\u540c\u7684\u54c8\u5e0c\u8868\u5b9e\u73b0\u7b56\u7565\uff0c\u4e0b\u9762\u4e3e\u51e0\u4e2a\u4f8b\u5b50\u3002

    • Python \u91c7\u7528\u5f00\u653e\u5bfb\u5740\u3002\u5b57\u5178 dict \u4f7f\u7528\u4f2a\u968f\u673a\u6570\u8fdb\u884c\u63a2\u6d4b\u3002
    • 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\u8f6c\u6362\u4e3a\u7ea2\u9ed1\u6811\u4ee5\u63d0\u5347\u67e5\u627e\u6027\u80fd\u3002
    • Go \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\uff0c\u53c8\u79f0\u300c\u6563\u5217\u8868\u300d\uff0c\u5b83\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\u4e2d\u8f93\u5165\u4e00\u4e2a\u952e key \uff0c\u5219\u53ef\u4ee5\u5728 \\(O(1)\\) \u65f6\u95f4\u5185\u83b7\u53d6\u5bf9\u5e94\u7684\u503c value \u3002

    \u5982\u56fe 6-1 \u6240\u793a\uff0c\u7ed9\u5b9a \\(n\\) \u4e2a\u5b66\u751f\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\u56fe 6-1 \u6240\u793a\u7684\u54c8\u5e0c\u8868\u6765\u5b9e\u73b0\u3002

    \u56fe 6-1 \u00a0 \u54c8\u5e0c\u8868\u7684\u62bd\u8c61\u8868\u793a

    \u9664\u54c8\u5e0c\u8868\u5916\uff0c\u6570\u7ec4\u548c\u94fe\u8868\u4e5f\u53ef\u4ee5\u5b9e\u73b0\u67e5\u8be2\u529f\u80fd\uff0c\u5b83\u4eec\u7684\u6548\u7387\u5bf9\u6bd4\u5982\u8868 6-1 \u6240\u793a\u3002

    • \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\u3002
    • \u67e5\u8be2\u5143\u7d20\uff1a\u7531\u4e8e\u6570\u7ec4\uff08\u94fe\u8868\uff09\u662f\u4e71\u5e8f\u7684\uff0c\u56e0\u6b64\u9700\u8981\u904d\u5386\u5176\u4e2d\u7684\u6240\u6709\u5143\u7d20\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002
    • \u5220\u9664\u5143\u7d20\uff1a\u9700\u8981\u5148\u67e5\u8be2\u5230\u5143\u7d20\uff0c\u518d\u4ece\u6570\u7ec4\uff08\u94fe\u8868\uff09\u4e2d\u5220\u9664\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002

    \u8868 6-1 \u00a0 \u5143\u7d20\u67e5\u8be2\u6548\u7387\u5bf9\u6bd4

    \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

    "},{"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\uff0c\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map.py
    # \u521d\u59cb\u5316\u54c8\u5e0c\u8868\nhmap: dict = {}\n\n# \u6dfb\u52a0\u64cd\u4f5c\n# \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nhmap[12836] = \"\u5c0f\u54c8\"\nhmap[15937] = \"\u5c0f\u5570\"\nhmap[16750] = \"\u5c0f\u7b97\"\nhmap[13276] = \"\u5c0f\u6cd5\"\nhmap[10583] = \"\u5c0f\u9e2d\"\n\n# \u67e5\u8be2\u64cd\u4f5c\n# \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nname: str = hmap[15937]\n\n# \u5220\u9664\u64cd\u4f5c\n# \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nhmap.pop(10583)\n
    hash_map.cpp
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nunordered_map<int, string> map;\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nstring name = map[15937];\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.erase(10583);\n
    hash_map.java
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nMap<Integer, String> map = new HashMap<>();\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.put(12836, \"\u5c0f\u54c8\");   \nmap.put(15937, \"\u5c0f\u5570\");   \nmap.put(16750, \"\u5c0f\u7b97\");   \nmap.put(13276, \"\u5c0f\u6cd5\");\nmap.put(10583, \"\u5c0f\u9e2d\");\n\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map.get(15937);\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583);\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)\n    { 12836, \"\u5c0f\u54c8\" },\n    { 15937, \"\u5c0f\u5570\" },\n    { 16750, \"\u5c0f\u7b97\" },\n    { 13276, \"\u5c0f\u6cd5\" },\n    { 10583, \"\u5c0f\u9e2d\" }\n};\n\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nstring name = map[15937];\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.Remove(10583);\n
    hash_map_test.go
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nhmap := make(map[int]string)\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nhmap[12836] = \"\u5c0f\u54c8\"\nhmap[15937] = \"\u5c0f\u5570\"\nhmap[16750] = \"\u5c0f\u7b97\"\nhmap[13276] = \"\u5c0f\u6cd5\"\nhmap[10583] = \"\u5c0f\u9e2d\"\n\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nname := hmap[15937]\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\ndelete(hmap, 10583)\n
    hash_map.swift
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nvar map: [Int: String] = [:]\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map[15937]!\n\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.js
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nconst map = new Map();\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet name = map.get(15937);\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\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\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.dart
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nMap<int, String> map = {};\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nString name = map[15937];\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583);\n
    hash_map.rs
    use std::collections::HashMap;\n\n/* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nlet mut map: HashMap<i32, String> = HashMap::new();\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u6dfb\u52a0\u952e\u503c\u5bf9 (key, value)\nmap.insert(12836, \"\u5c0f\u54c8\".to_string());\nmap.insert(15937, \"\u5c0f\u5570\".to_string());\nmap.insert(16750, \"\u5c0f\u7b97\".to_string());\nmap.insert(13279, \"\u5c0f\u6cd5\".to_string());\nmap.insert(10583, \"\u5c0f\u9e2d\".to_string());\n\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nlet _name: Option<&String> = map.get(&15937);\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nlet _removed_value: Option<String> = map.remove(&10583);\n
    hash_map.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u8868\n
    hash_map.kt
    /* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nval map = HashMap<Int,String>()\n\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\n/* \u67e5\u8be2\u64cd\u4f5c */\n// \u5411\u54c8\u5e0c\u8868\u4e2d\u8f93\u5165\u952e key \uff0c\u5f97\u5230\u503c value\nval name = map[15937]\n\n/* \u5220\u9664\u64cd\u4f5c */\n// \u5728\u54c8\u5e0c\u8868\u4e2d\u5220\u9664\u952e\u503c\u5bf9 (key, value)\nmap.remove(10583)\n
    hash_map.rb
    \n
    hash_map.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u54c8\u5e0c\u8868\u6709\u4e09\u79cd\u5e38\u7528\u7684\u904d\u5386\u65b9\u5f0f\uff1a\u904d\u5386\u952e\u503c\u5bf9\u3001\u904d\u5386\u952e\u548c\u904d\u5386\u503c\u3002\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig hash_map.py
    # \u904d\u5386\u54c8\u5e0c\u8868\n# \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor key, value in hmap.items():\n    print(key, \"->\", value)\n# \u5355\u72ec\u904d\u5386\u952e key\nfor key in hmap.keys():\n    print(key)\n# \u5355\u72ec\u904d\u5386\u503c value\nfor value in hmap.values():\n    print(value)\n
    hash_map.cpp
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor (auto kv: map) {\n    cout << kv.first << \" -> \" << kv.second << endl;\n}\n// \u4f7f\u7528\u8fed\u4ee3\u5668\u904d\u5386 key->value\nfor (auto iter = map.begin(); iter != map.end(); iter++) {\n    cout << iter->first << \"->\" << iter->second << endl;\n}\n
    hash_map.java
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor (Map.Entry <Integer, String> kv: map.entrySet()) {\n    System.out.println(kv.getKey() + \" -> \" + kv.getValue());\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor (int key: map.keySet()) {\n    System.out.println(key);\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor (String val: map.values()) {\n    System.out.println(val);\n}\n
    hash_map.cs
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nforeach (var kv in map) {\n    Console.WriteLine(kv.Key + \" -> \" + kv.Value);\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nforeach (int key in map.Keys) {\n    Console.WriteLine(key);\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nforeach (string val in map.Values) {\n    Console.WriteLine(val);\n}\n
    hash_map_test.go
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor key, value := range hmap {\n    fmt.Println(key, \"->\", value)\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor key := range hmap {\n    fmt.Println(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor _, value := range hmap {\n    fmt.Println(value)\n}\n
    hash_map.swift
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nfor (key, value) in map {\n    print(\"\\(key) -> \\(value)\")\n}\n// \u5355\u72ec\u904d\u5386\u952e Key\nfor key in map.keys {\n    print(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c Value\nfor value in map.values {\n    print(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()) {\n    console.info(k + ' -> ' + v);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u952e Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u503c Value');\nfor (const v of map.values()) {\n    console.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()) {\n    console.info(k + ' -> ' + v);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u952e Key');\nfor (const k of map.keys()) {\n    console.info(k);\n}\nconsole.info('\\n\u5355\u72ec\u904d\u5386\u503c Value');\nfor (const v of map.values()) {\n    console.info(v);\n}\n
    hash_map.dart
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nmap.forEach((key, value) {\n  print('$key -> $value');\n});\n\n// \u5355\u72ec\u904d\u5386\u952e Key\nmap.keys.forEach((key) {\n  print(key);\n});\n\n// \u5355\u72ec\u904d\u5386\u503c Value\nmap.values.forEach((value) {\n  print(value);\n});\n
    hash_map.rs
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 Key->Value\nfor (key, value) in &map {\n    println!(\"{key} -> {value}\");\n}\n\n// \u5355\u72ec\u904d\u5386\u952e Key\nfor key in map.keys() {\n    println!(\"{key}\"); \n}\n\n// \u5355\u72ec\u904d\u5386\u503c Value\nfor value in map.values() {\n    println!(\"{value}\");\n}\n
    hash_map.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u54c8\u5e0c\u8868\n
    hash_map.kt
    /* \u904d\u5386\u54c8\u5e0c\u8868 */\n// \u904d\u5386\u952e\u503c\u5bf9 key->value\nfor ((key, value) in map) {\n    println(\"$key -> $value\")\n}\n// \u5355\u72ec\u904d\u5386\u952e key\nfor (key in map.keys) {\n    println(key)\n}\n// \u5355\u72ec\u904d\u5386\u503c value\nfor (_val in map.values) {\n    println(_val)\n}\n
    hash_map.rb
    \n
    hash_map.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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 \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\u4ee5\u4e0b\u4e24\u6b65\u3002

    1. \u901a\u8fc7\u67d0\u79cd\u54c8\u5e0c\u7b97\u6cd5 hash() \u8ba1\u7b97\u5f97\u5230\u54c8\u5e0c\u503c\u3002
    2. \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\u56fe 6-2 \u4ee5 key \u5b66\u53f7\u548c value \u59d3\u540d\u4e3a\u4f8b\uff0c\u5c55\u793a\u4e86\u54c8\u5e0c\u51fd\u6570\u7684\u5de5\u4f5c\u539f\u7406\u3002

    \u56fe 6-2 \u00a0 \u54c8\u5e0c\u51fd\u6570\u5de5\u4f5c\u539f\u7406

    \u4ee5\u4e0b\u4ee3\u7801\u5b9e\u73b0\u4e86\u4e00\u4e2a\u7b80\u5355\u54c8\u5e0c\u8868\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_hash_map.py
    class Pair:\n    \"\"\"\u952e\u503c\u5bf9\"\"\"\n\n    def __init__(self, key: int, val: str):\n        self.key = key\n        self.val = val\n\nclass ArrayHashMap:\n    \"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        # \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        self.buckets: list[Pair | None] = [None] * 100\n\n    def hash_func(self, key: int) -> int:\n        \"\"\"\u54c8\u5e0c\u51fd\u6570\"\"\"\n        index = key % 100\n        return index\n\n    def get(self, key: int) -> str:\n        \"\"\"\u67e5\u8be2\u64cd\u4f5c\"\"\"\n        index: int = self.hash_func(key)\n        pair: Pair = self.buckets[index]\n        if pair is None:\n            return None\n        return pair.val\n\n    def put(self, key: int, val: str):\n        \"\"\"\u6dfb\u52a0\u64cd\u4f5c\"\"\"\n        pair = Pair(key, val)\n        index: int = self.hash_func(key)\n        self.buckets[index] = pair\n\n    def remove(self, key: int):\n        \"\"\"\u5220\u9664\u64cd\u4f5c\"\"\"\n        index: int = self.hash_func(key)\n        # \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\n        self.buckets[index] = None\n\n    def entry_set(self) -> list[Pair]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\"\"\"\n        result: list[Pair] = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair)\n        return result\n\n    def key_set(self) -> list[int]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u952e\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.key)\n        return result\n\n    def value_set(self) -> list[str]:\n        \"\"\"\u83b7\u53d6\u6240\u6709\u503c\"\"\"\n        result = []\n        for pair in self.buckets:\n            if pair is not None:\n                result.append(pair.val)\n        return result\n\n    def print(self):\n        \"\"\"\u6253\u5370\u54c8\u5e0c\u8868\"\"\"\n        for pair in self.buckets:\n            if pair is not None:\n                print(pair.key, \"->\", pair.val)\n
    array_hash_map.cpp
    /* \u952e\u503c\u5bf9 */\nstruct Pair {\n  public:\n    int key;\n    string val;\n    Pair(int key, string val) {\n        this->key = key;\n        this->val = val;\n    }\n};\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n  private:\n    vector<Pair *> buckets;\n\n  public:\n    ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = vector<Pair *>(100);\n    }\n\n    ~ArrayHashMap() {\n        // \u91ca\u653e\u5185\u5b58\n        for (const auto &bucket : buckets) {\n            delete bucket;\n        }\n        buckets.clear();\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    string get(int key) {\n        int index = hashFunc(key);\n        Pair *pair = buckets[index];\n        if (pair == nullptr)\n            return \"\";\n        return pair->val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    void put(int key, string val) {\n        Pair *pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    void remove(int key) {\n        int index = hashFunc(key);\n        // \u91ca\u653e\u5185\u5b58\u5e76\u7f6e\u4e3a nullptr\n        delete buckets[index];\n        buckets[index] = nullptr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    vector<Pair *> pairSet() {\n        vector<Pair *> pairSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                pairSet.push_back(pair);\n            }\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    vector<int> keySet() {\n        vector<int> keySet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                keySet.push_back(pair->key);\n            }\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    vector<string> valueSet() {\n        vector<string> valueSet;\n        for (Pair *pair : buckets) {\n            if (pair != nullptr) {\n                valueSet.push_back(pair->val);\n            }\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    void print() {\n        for (Pair *kv : pairSet()) {\n            cout << kv->key << \" -> \" << kv->val << endl;\n        }\n    }\n};\n
    array_hash_map.java
    /* \u952e\u503c\u5bf9 */\nclass Pair {\n    public int key;\n    public String val;\n\n    public Pair(int key, String val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private List<Pair> buckets;\n\n    public ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = new ArrayList<>();\n        for (int i = 0; i < 100; i++) {\n            buckets.add(null);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private int hashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public String get(int key) {\n        int index = hashFunc(key);\n        Pair pair = buckets.get(index);\n        if (pair == null)\n            return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void put(int key, String val) {\n        Pair pair = new Pair(key, val);\n        int index = hashFunc(key);\n        buckets.set(index, pair);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void remove(int key) {\n        int index = hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets.set(index, null);\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public List<Pair> pairSet() {\n        List<Pair> pairSet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                pairSet.add(pair);\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public List<Integer> keySet() {\n        List<Integer> keySet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                keySet.add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public List<String> valueSet() {\n        List<String> valueSet = new ArrayList<>();\n        for (Pair pair : buckets) {\n            if (pair != null)\n                valueSet.add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void print() {\n        for (Pair kv : pairSet()) {\n            System.out.println(kv.key + \" -> \" + kv.val);\n        }\n    }\n}\n
    array_hash_map.cs
    /* \u952e\u503c\u5bf9 int->string */\nclass Pair(int key, string val) {\n    public int key = key;\n    public string val = val;\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    List<Pair?> buckets;\n    public ArrayHashMap() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = [];\n        for (int i = 0; i < 100; i++) {\n            buckets.Add(null);\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    int HashFunc(int key) {\n        int index = key % 100;\n        return index;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public string? Get(int key) {\n        int index = HashFunc(key);\n        Pair? pair = buckets[index];\n        if (pair == null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public void Put(int key, string val) {\n        Pair pair = new(key, val);\n        int index = HashFunc(key);\n        buckets[index] = pair;\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public void Remove(int key) {\n        int index = HashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public List<Pair> PairSet() {\n        List<Pair> pairSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                pairSet.Add(pair);\n        }\n        return pairSet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public List<int> KeySet() {\n        List<int> keySet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                keySet.Add(pair.key);\n        }\n        return keySet;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public List<string> ValueSet() {\n        List<string> valueSet = [];\n        foreach (Pair? pair in buckets) {\n            if (pair != null)\n                valueSet.Add(pair.val);\n        }\n        return valueSet;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public void Print() {\n        foreach (Pair kv in PairSet()) {\n            Console.WriteLine(kv.key + \" -> \" + kv.val);\n        }\n    }\n}\n
    array_hash_map.go
    /* \u952e\u503c\u5bf9 */\ntype pair struct {\n    key int\n    val string\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntype arrayHashMap struct {\n    buckets []*pair\n}\n\n/* \u521d\u59cb\u5316\u54c8\u5e0c\u8868 */\nfunc newArrayHashMap() *arrayHashMap {\n    // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n    buckets := make([]*pair, 100)\n    return &arrayHashMap{buckets: buckets}\n}\n\n/* \u54c8\u5e0c\u51fd\u6570 */\nfunc (a *arrayHashMap) hashFunc(key int) int {\n    index := key % 100\n    return index\n}\n\n/* \u67e5\u8be2\u64cd\u4f5c */\nfunc (a *arrayHashMap) get(key int) string {\n    index := a.hashFunc(key)\n    pair := a.buckets[index]\n    if pair == nil {\n        return \"Not Found\"\n    }\n    return pair.val\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nfunc (a *arrayHashMap) put(key int, val string) {\n    pair := &pair{key: key, val: val}\n    index := a.hashFunc(key)\n    a.buckets[index] = pair\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nfunc (a *arrayHashMap) remove(key int) {\n    index := a.hashFunc(key)\n    // \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\n    a.buckets[index] = nil\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e\u5bf9 */\nfunc (a *arrayHashMap) pairSet() []*pair {\n    var pairs []*pair\n    for _, pair := range a.buckets {\n        if pair != nil {\n            pairs = append(pairs, pair)\n        }\n    }\n    return pairs\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e */\nfunc (a *arrayHashMap) keySet() []int {\n    var keys []int\n    for _, pair := range a.buckets {\n        if pair != nil {\n            keys = append(keys, pair.key)\n        }\n    }\n    return keys\n}\n\n/* \u83b7\u53d6\u6240\u6709\u503c */\nfunc (a *arrayHashMap) valueSet() []string {\n    var values []string\n    for _, pair := range a.buckets {\n        if pair != nil {\n            values = append(values, pair.val)\n        }\n    }\n    return values\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nfunc (a *arrayHashMap) print() {\n    for _, pair := range a.buckets {\n        if pair != nil {\n            fmt.Println(pair.key, \"->\", pair.val)\n        }\n    }\n}\n
    array_hash_map.swift
    /* \u952e\u503c\u5bf9 */\nclass Pair: Equatable {\n    public var key: Int\n    public var val: String\n\n    public init(key: Int, val: String) {\n        self.key = key\n        self.val = val\n    }\n\n    public static func == (lhs: Pair, rhs: Pair) -> Bool {\n        lhs.key == rhs.key && lhs.val == rhs.val\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private var buckets: [Pair?]\n\n    init() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        buckets = Array(repeating: nil, count: 100)\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private func hashFunc(key: Int) -> Int {\n        let index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    func get(key: Int) -> String? {\n        let index = hashFunc(key: key)\n        let pair = buckets[index]\n        return pair?.val\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    func put(key: Int, val: String) {\n        let pair = Pair(key: key, val: val)\n        let index = hashFunc(key: key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    func remove(key: Int) {\n        let index = hashFunc(key: key)\n        // \u7f6e\u4e3a nil \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = nil\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    func pairSet() -> [Pair] {\n        buckets.compactMap { $0 }\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    func keySet() -> [Int] {\n        buckets.compactMap { $0?.key }\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    func valueSet() -> [String] {\n        buckets.compactMap { $0?.val }\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    func print() {\n        for pair in pairSet() {\n            Swift.print(\"\\(pair.key) -> \\(pair.val)\")\n        }\n    }\n}\n
    array_hash_map.js
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\n    constructor(key, val) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    #buckets;\n    constructor() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        this.#buckets = new Array(100).fill(null);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    #hashFunc(key) {\n        return key % 100;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    get(key) {\n        let index = this.#hashFunc(key);\n        let pair = this.#buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    set(key, val) {\n        let index = this.#hashFunc(key);\n        this.#buckets[index] = new Pair(key, val);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    delete(key) {\n        let index = this.#hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        this.#buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    entries() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    keys() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    values() {\n        let arr = [];\n        for (let i = 0; i < this.#buckets.length; i++) {\n            if (this.#buckets[i]) {\n                arr.push(this.#buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -> ${pair.val}`);\n        }\n    }\n}\n
    array_hash_map.ts
    /* \u952e\u503c\u5bf9 Number -> String */\nclass Pair {\n    public key: number;\n    public val: string;\n\n    constructor(key: number, val: string) {\n        this.key = key;\n        this.val = val;\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private readonly buckets: (Pair | null)[];\n\n    constructor() {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        this.buckets = new Array(100).fill(null);\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    private hashFunc(key: number): number {\n        return key % 100;\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    public get(key: number): string | null {\n        let index = this.hashFunc(key);\n        let pair = this.buckets[index];\n        if (pair === null) return null;\n        return pair.val;\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    public set(key: number, val: string) {\n        let index = this.hashFunc(key);\n        this.buckets[index] = new Pair(key, val);\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    public delete(key: number) {\n        let index = this.hashFunc(key);\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        this.buckets[index] = null;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    public entries(): (Pair | null)[] {\n        let arr: (Pair | null)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i]);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    public keys(): (number | undefined)[] {\n        let arr: (number | undefined)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].key);\n            }\n        }\n        return arr;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    public values(): (string | undefined)[] {\n        let arr: (string | undefined)[] = [];\n        for (let i = 0; i < this.buckets.length; i++) {\n            if (this.buckets[i]) {\n                arr.push(this.buckets[i].val);\n            }\n        }\n        return arr;\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    public print() {\n        let pairSet = this.entries();\n        for (const pair of pairSet) {\n            console.info(`${pair.key} -> ${pair.val}`);\n        }\n    }\n}\n
    array_hash_map.dart
    /* \u952e\u503c\u5bf9 */\nclass Pair {\n  int key;\n  String val;\n  Pair(this.key, this.val);\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n  late List<Pair?> _buckets;\n\n  ArrayHashMap() {\n    // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n    _buckets = List.filled(100, null);\n  }\n\n  /* \u54c8\u5e0c\u51fd\u6570 */\n  int _hashFunc(int key) {\n    final int index = key % 100;\n    return index;\n  }\n\n  /* \u67e5\u8be2\u64cd\u4f5c */\n  String? get(int key) {\n    final int index = _hashFunc(key);\n    final Pair? pair = _buckets[index];\n    if (pair == null) {\n      return null;\n    }\n    return pair.val;\n  }\n\n  /* \u6dfb\u52a0\u64cd\u4f5c */\n  void put(int key, String val) {\n    final Pair pair = Pair(key, val);\n    final int index = _hashFunc(key);\n    _buckets[index] = pair;\n  }\n\n  /* \u5220\u9664\u64cd\u4f5c */\n  void remove(int key) {\n    final int index = _hashFunc(key);\n    _buckets[index] = null;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n  List<Pair> pairSet() {\n    List<Pair> pairSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        pairSet.add(pair);\n      }\n    }\n    return pairSet;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u952e */\n  List<int> keySet() {\n    List<int> keySet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        keySet.add(pair.key);\n      }\n    }\n    return keySet;\n  }\n\n  /* \u83b7\u53d6\u6240\u6709\u503c */\n  List<String> values() {\n    List<String> valueSet = [];\n    for (final Pair? pair in _buckets) {\n      if (pair != null) {\n        valueSet.add(pair.val);\n      }\n    }\n    return valueSet;\n  }\n\n  /* \u6253\u5370\u54c8\u5e0c\u8868 */\n  void printHashMap() {\n    for (final Pair kv in pairSet()) {\n      print(\"${kv.key} -> ${kv.val}\");\n    }\n  }\n}\n
    array_hash_map.rs
    /* \u952e\u503c\u5bf9 */\n#[derive(Debug, Clone, PartialEq)]\npub struct Pair {\n    pub key: i32,\n    pub val: String,\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\npub struct ArrayHashMap {\n    buckets: Vec<Option<Pair>>,\n}\n\nimpl ArrayHashMap {\n    pub fn new() -> ArrayHashMap {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        Self {\n            buckets: vec![None; 100],\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fn hash_func(&self, key: i32) -> usize {\n        key as usize % 100\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    pub fn get(&self, key: i32) -> Option<&String> {\n        let index = self.hash_func(key);\n        self.buckets[index].as_ref().map(|pair| &pair.val)\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    pub fn put(&mut self, key: i32, val: &str) {\n        let index = self.hash_func(key);\n        self.buckets[index] = Some(Pair {\n            key,\n            val: val.to_string(),\n        });\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    pub fn remove(&mut self, key: i32) {\n        let index = self.hash_func(key);\n        // \u7f6e\u4e3a None \uff0c\u4ee3\u8868\u5220\u9664\n        self.buckets[index] = None;\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    pub fn entry_set(&self) -> Vec<&Pair> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref())\n            .collect()\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    pub fn key_set(&self) -> Vec<&i32> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &pair.key))\n            .collect()\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    pub fn value_set(&self) -> Vec<&String> {\n        self.buckets\n            .iter()\n            .filter_map(|pair| pair.as_ref().map(|pair| &pair.val))\n            .collect()\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    pub fn print(&self) {\n        for pair in self.entry_set() {\n            println!(\"{} -> {}\", pair.key, pair.val);\n        }\n    }\n}\n
    array_hash_map.c
    /* \u952e\u503c\u5bf9 int->string */\ntypedef struct {\n    int key;\n    char *val;\n} Pair;\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\ntypedef struct {\n    Pair *buckets[HASHTABLE_CAPACITY];\n} ArrayHashMap;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayHashMap *newArrayHashMap() {\n    ArrayHashMap *hmap = malloc(sizeof(ArrayHashMap));\n    return hmap;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayHashMap(ArrayHashMap *hmap) {\n    for (int i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            free(hmap->buckets[i]->val);\n            free(hmap->buckets[i]);\n        }\n    }\n    free(hmap);\n}\n\n/* \u6dfb\u52a0\u64cd\u4f5c */\nvoid put(ArrayHashMap *hmap, const int key, const char *val) {\n    Pair *Pair = malloc(sizeof(Pair));\n    Pair->key = key;\n    Pair->val = malloc(strlen(val) + 1);\n    strcpy(Pair->val, val);\n\n    int index = hashFunc(key);\n    hmap->buckets[index] = Pair;\n}\n\n/* \u5220\u9664\u64cd\u4f5c */\nvoid removeItem(ArrayHashMap *hmap, const int key) {\n    int index = hashFunc(key);\n    free(hmap->buckets[index]->val);\n    free(hmap->buckets[index]);\n    hmap->buckets[index] = NULL;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\nvoid pairSet(ArrayHashMap *hmap, MapSet *set) {\n    Pair *entries;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    entries = malloc(sizeof(Pair) * total);\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            entries[index].key = hmap->buckets[i]->key;\n            entries[index].val = malloc(strlen(hmap->buckets[i]->val) + 1);\n            strcpy(entries[index].val, hmap->buckets[i]->val);\n            index++;\n        }\n    }\n    set->set = entries;\n    set->len = total;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u952e */\nvoid keySet(ArrayHashMap *hmap, MapSet *set) {\n    int *keys;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    keys = malloc(total * sizeof(int));\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            keys[index] = hmap->buckets[i]->key;\n            index++;\n        }\n    }\n    set->set = keys;\n    set->len = total;\n}\n\n/* \u83b7\u53d6\u6240\u6709\u503c */\nvoid valueSet(ArrayHashMap *hmap, MapSet *set) {\n    char **vals;\n    int i = 0, index = 0;\n    int total = 0;\n    /* \u7edf\u8ba1\u6709\u6548\u952e\u503c\u5bf9\u6570\u91cf */\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            total++;\n        }\n    }\n    vals = malloc(total * sizeof(char *));\n    for (i = 0; i < HASHTABLE_CAPACITY; i++) {\n        if (hmap->buckets[i] != NULL) {\n            vals[index] = hmap->buckets[i]->val;\n            index++;\n        }\n    }\n    set->set = vals;\n    set->len = total;\n}\n\n/* \u6253\u5370\u54c8\u5e0c\u8868 */\nvoid print(ArrayHashMap *hmap) {\n    int i;\n    MapSet set;\n    pairSet(hmap, &set);\n    Pair *entries = (Pair *)set.set;\n    for (i = 0; i < set.len; i++) {\n        printf(\"%d -> %s\\n\", entries[i].key, entries[i].val);\n    }\n    free(set.set);\n}\n
    array_hash_map.kt
    /* \u952e\u503c\u5bf9 */\nclass Pair(\n    var key: Int,\n    var value: String\n)\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private val buckets = arrayOfNulls<Pair>(100)\n\n    init {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        for (i in 0..<100) {\n            buckets[i] = null\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair.value\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        val pair = Pair(key, value)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    fun pairSet(): MutableList<Pair> {\n        val pairSet = ArrayList<Pair>()\n        for (pair in buckets) {\n            if (pair != null) pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    fun keySet(): MutableList<Int> {\n        val keySet = ArrayList<Int>()\n        for (pair in buckets) {\n            if (pair != null) keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    fun valueSet(): MutableList<String> {\n        val valueSet = ArrayList<String>()\n        for (pair in buckets) {\n            pair?.let { valueSet.add(it.value) }\n        }\n        return valueSet\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val value = kv.value\n            println(\"${key}->${value}\")\n        }\n    }\n}\n\n/* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868 */\nclass ArrayHashMap {\n    private val buckets = arrayOfNulls<Pair>(100)\n\n    init {\n        // \u521d\u59cb\u5316\u6570\u7ec4\uff0c\u5305\u542b 100 \u4e2a\u6876\n        for (i in 0..<100) {\n            buckets[i] = null\n        }\n    }\n\n    /* \u54c8\u5e0c\u51fd\u6570 */\n    fun hashFunc(key: Int): Int {\n        val index = key % 100\n        return index\n    }\n\n    /* \u67e5\u8be2\u64cd\u4f5c */\n    fun get(key: Int): String? {\n        val index = hashFunc(key)\n        val pair = buckets[index] ?: return null\n        return pair.value\n    }\n\n    /* \u6dfb\u52a0\u64cd\u4f5c */\n    fun put(key: Int, value: String) {\n        val pair = Pair(key, value)\n        val index = hashFunc(key)\n        buckets[index] = pair\n    }\n\n    /* \u5220\u9664\u64cd\u4f5c */\n    fun remove(key: Int) {\n        val index = hashFunc(key)\n        // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n        buckets[index] = null\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9 */\n    fun pairSet(): MutableList<Pair> {\n        val pairSet = ArrayList<Pair>()\n        for (pair in buckets) {\n            if (pair != null) pairSet.add(pair)\n        }\n        return pairSet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u952e */\n    fun keySet(): MutableList<Int> {\n        val keySet = ArrayList<Int>()\n        for (pair in buckets) {\n            if (pair != null) keySet.add(pair.key)\n        }\n        return keySet\n    }\n\n    /* \u83b7\u53d6\u6240\u6709\u503c */\n    fun valueSet(): MutableList<String> {\n        val valueSet = ArrayList<String>()\n        for (pair in buckets) {\n            pair?.let { valueSet.add(it.value) }\n        }\n        return valueSet\n    }\n\n    /* \u6253\u5370\u54c8\u5e0c\u8868 */\n    fun print() {\n        for (kv in pairSet()) {\n            val key = kv.key\n            val value = kv.value\n            println(\"${key}->${value}\")\n        }\n    }\n}\n
    array_hash_map.rb
    [class]{Pair}-[func]{}\n\n[class]{ArrayHashMap}-[func]{}\n
    array_hash_map.zig
    // \u952e\u503c\u5bf9\nconst Pair = struct {\n    key: usize = undefined,\n    val: []const u8 = undefined,\n\n   pub fn init(key: usize, val: []const u8) Pair {\n        return Pair {\n            .key = key,\n            .val = val,\n        };\n    }\n};\n\n// \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u54c8\u5e0c\u8868\nfn ArrayHashMap(comptime T: type) type {\n    return struct {\n        bucket: ?std.ArrayList(?T) = null,\n        mem_allocator: std.mem.Allocator = undefined,\n\n        const Self = @This();\n\n        // \u6784\u9020\u51fd\u6570\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            self.mem_allocator = allocator;\n            // \u521d\u59cb\u5316\u4e00\u4e2a\u957f\u5ea6\u4e3a 100 \u7684\u6876\uff08\u6570\u7ec4\uff09\n            self.bucket = std.ArrayList(?T).init(self.mem_allocator);\n            var i: i32 = 0;\n            while (i < 100) : (i += 1) {\n                try self.bucket.?.append(null);\n            }\n        }\n\n        // \u6790\u6784\u51fd\u6570\n        pub fn deinit(self: *Self) void {\n            if (self.bucket != null) self.bucket.?.deinit();\n        }\n\n        // \u54c8\u5e0c\u51fd\u6570\n        fn hashFunc(key: usize) usize {\n            var index = key % 100;\n            return index;\n        }\n\n        // \u67e5\u8be2\u64cd\u4f5c\n        pub fn get(self: *Self, key: usize) []const u8 {\n            var index = hashFunc(key);\n            var pair = self.bucket.?.items[index];\n            return pair.?.val;\n        }\n\n        // \u6dfb\u52a0\u64cd\u4f5c\n        pub fn put(self: *Self, key: usize, val: []const u8) !void {\n            var pair = Pair.init(key, val);\n            var index = hashFunc(key);\n            self.bucket.?.items[index] = pair;\n        }\n\n        // \u5220\u9664\u64cd\u4f5c\n        pub fn remove(self: *Self, key: usize) !void {\n            var index = hashFunc(key);\n            // \u7f6e\u4e3a null \uff0c\u4ee3\u8868\u5220\u9664\n            self.bucket.?.items[index] = null;\n        }       \n\n        // \u83b7\u53d6\u6240\u6709\u952e\u503c\u5bf9\n        pub fn pairSet(self: *Self) !std.ArrayList(T) {\n            var entry_set = std.ArrayList(T).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try entry_set.append(item.?);\n            }\n            return entry_set;\n        }  \n\n        // \u83b7\u53d6\u6240\u6709\u952e\n        pub fn keySet(self: *Self) !std.ArrayList(usize) {\n            var key_set = std.ArrayList(usize).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try key_set.append(item.?.key);\n            }\n            return key_set;\n        }  \n\n        // \u83b7\u53d6\u6240\u6709\u503c\n        pub fn valueSet(self: *Self) !std.ArrayList([]const u8) {\n            var value_set = std.ArrayList([]const u8).init(self.mem_allocator);\n            for (self.bucket.?.items) |item| {\n                if (item == null) continue;\n                try value_set.append(item.?.val);\n            }\n            return value_set;\n        }\n\n        // \u6253\u5370\u54c8\u5e0c\u8868\n        pub fn print(self: *Self) !void {\n            var entry_set = try self.pairSet();\n            defer entry_set.deinit();\n            for (entry_set.items) |item| {\n                std.debug.print(\"{} -> {s}\\n\", .{item.key, item.val});\n            }\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_hashing/hash_map/#613","title":"6.1.3 \u00a0 \u54c8\u5e0c\u51b2\u7a81\u4e0e\u6269\u5bb9","text":"

    \u4ece\u672c\u8d28\u4e0a\u770b\uff0c\u54c8\u5e0c\u51fd\u6570\u7684\u4f5c\u7528\u662f\u5c06\u6240\u6709 key \u6784\u6210\u7684\u8f93\u5165\u7a7a\u95f4\u6620\u5c04\u5230\u6570\u7ec4\u6240\u6709\u7d22\u5f15\u6784\u6210\u7684\u8f93\u51fa\u7a7a\u95f4\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

    12836 % 100 = 36\n20336 % 100 = 36\n

    \u5982\u56fe 6-3 \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

    \u56fe 6-3 \u00a0 \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\u56fe 6-4 \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

    \u56fe 6-4 \u00a0 \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\uff1b\u5e76\u4e14\u7531\u4e8e\u54c8\u5e0c\u8868\u5bb9\u91cf capacity \u6539\u53d8\uff0c\u6211\u4eec\u9700\u8981\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u6765\u91cd\u65b0\u8ba1\u7b97\u6240\u6709\u952e\u503c\u5bf9\u7684\u5b58\u50a8\u4f4d\u7f6e\uff0c\u8fd9\u8fdb\u4e00\u6b65\u589e\u52a0\u4e86\u6269\u5bb9\u8fc7\u7a0b\u7684\u8ba1\u7b97\u5f00\u9500\u3002\u4e3a\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

    \u300c\u8d1f\u8f7d\u56e0\u5b50 load factor\u300d\u662f\u54c8\u5e0c\u8868\u7684\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\u7528\u4e8e\u8861\u91cf\u54c8\u5e0c\u51b2\u7a81\u7684\u4e25\u91cd\u7a0b\u5ea6\uff0c\u4e5f\u5e38\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\u6269\u5bb9\u81f3\u539f\u5148\u7684 \\(2\\) \u500d\u3002

    "},{"location":"chapter_hashing/summary/","title":"6.4 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_hashing/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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\u901a\u8fc7\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\u5747\u5300\u5206\u5e03\uff0c\u51cf\u5c11\u54c8\u5e0c\u51b2\u7a81\u3002
    • \u5e38\u89c1\u7684\u54c8\u5e0c\u7b97\u6cd5\u5305\u62ec MD5\u3001SHA-1\u3001SHA-2 \u548c SHA-3 \u7b49\u3002MD5 \u5e38\u7528\u4e8e\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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\u54c8\u5e0c\u8868\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5728\u4ec0\u4e48\u60c5\u51b5\u4e0b\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\u5f97\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

    Q\uff1a\u4e3a\u4ec0\u4e48\u4e0d\u4f7f\u7528\u54c8\u5e0c\u51fd\u6570 \\(f(x) = x\\) \u5462\uff1f\u8fd9\u6837\u5c31\u4e0d\u4f1a\u6709\u51b2\u7a81\u4e86\u3002

    \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

    Q\uff1a\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\u5b83\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\u5185\u5b58\u672a\u4f7f\u7528\u3002

    \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

    Q\uff1a\u591a\u6b21\u54c8\u5e0c\u6709\u4e0d\u80fd\u76f4\u63a5\u5220\u9664\u5143\u7d20\u7684\u7f3a\u9677\u5417\uff1f\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\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\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u7a7a\u95f4\u53ef\u4ee5\u518d\u6b21\u4f7f\u7528\u3002\u5f53\u5c06\u65b0\u5143\u7d20\u63d2\u5165\u54c8\u5e0c\u8868\uff0c\u5e76\u4e14\u901a\u8fc7\u54c8\u5e0c\u51fd\u6570\u627e\u5230\u6807\u8bb0\u4e3a\u5df2\u5220\u9664\u7684\u4f4d\u7f6e\u65f6\uff0c\u8be5\u4f4d\u7f6e\u53ef\u4ee5\u88ab\u65b0\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

    Q\uff1a\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

    Q\uff1a\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\u6a21\uff08\u53d6\u4f59\uff09\uff0c\u8ba9\u8f93\u51fa\u503c\u843d\u5728\u6570\u7ec4\u7d22\u5f15\u8303\u56f4\u5185\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":"\u7b2c 8 \u7ae0 \u00a0 \u5806","text":"

    Abstract

    \u5806\u5c31\u50cf\u662f\u5c71\u5cb3\u5cf0\u5ce6\uff0c\u5c42\u53e0\u8d77\u4f0f\u3001\u5f62\u6001\u5404\u5f02\u3002

    \u5ea7\u5ea7\u5c71\u5cf0\u9ad8\u4f4e\u9519\u843d\uff0c\u800c\u6700\u9ad8\u7684\u5c71\u5cf0\u603b\u662f\u6700\u5148\u6620\u5165\u773c\u5e18\u3002

    "},{"location":"chapter_heap/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 8.1 \u00a0 \u5806
    • 8.2 \u00a0 \u5efa\u5806\u64cd\u4f5c
    • 8.3 \u00a0 Top-k \u95ee\u9898
    • 8.4 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_heap/build_heap/","title":"8.2 \u00a0 \u5efa\u5806\u64cd\u4f5c","text":"

    \u5728\u67d0\u4e9b\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u5e0c\u671b\u4f7f\u7528\u4e00\u4e2a\u5217\u8868\u7684\u6240\u6709\u5143\u7d20\u6765\u6784\u5efa\u4e00\u4e2a\u5806\uff0c\u8fd9\u4e2a\u8fc7\u7a0b\u88ab\u79f0\u4e3a\u201c\u5efa\u5806\u64cd\u4f5c\u201d\u3002

    "},{"location":"chapter_heap/build_heap/#821","title":"8.2.1 \u00a0 \u501f\u52a9\u5165\u5806\u64cd\u4f5c\u5b9e\u73b0","text":"

    \u6211\u4eec\u9996\u5148\u521b\u5efa\u4e00\u4e2a\u7a7a\u5806\uff0c\u7136\u540e\u904d\u5386\u5217\u8868\uff0c\u4f9d\u6b21\u5bf9\u6bcf\u4e2a\u5143\u7d20\u6267\u884c\u201c\u5165\u5806\u64cd\u4f5c\u201d\uff0c\u5373\u5148\u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u5806\u7684\u5c3e\u90e8\uff0c\u518d\u5bf9\u8be5\u5143\u7d20\u6267\u884c\u201c\u4ece\u5e95\u81f3\u9876\u201d\u5806\u5316\u3002

    \u6bcf\u5f53\u4e00\u4e2a\u5143\u7d20\u5165\u5806\uff0c\u5806\u7684\u957f\u5ea6\u5c31\u52a0\u4e00\u3002\u7531\u4e8e\u8282\u70b9\u662f\u4ece\u9876\u5230\u5e95\u4f9d\u6b21\u88ab\u6dfb\u52a0\u8fdb\u4e8c\u53c9\u6811\u7684\uff0c\u56e0\u6b64\u5806\u662f\u201c\u81ea\u4e0a\u800c\u4e0b\u201d\u6784\u5efa\u7684\u3002

    \u8bbe\u5143\u7d20\u6570\u91cf\u4e3a \\(n\\) \uff0c\u6bcf\u4e2a\u5143\u7d20\u7684\u5165\u5806\u64cd\u4f5c\u4f7f\u7528 \\(O(\\log{n})\\) \u65f6\u95f4\uff0c\u56e0\u6b64\u8be5\u5efa\u5806\u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n \\log n)\\) \u3002

    "},{"location":"chapter_heap/build_heap/#822","title":"8.2.2 \u00a0 \u901a\u8fc7\u904d\u5386\u5806\u5316\u5b9e\u73b0","text":"

    \u5b9e\u9645\u4e0a\uff0c\u6211\u4eec\u53ef\u4ee5\u5b9e\u73b0\u4e00\u79cd\u66f4\u4e3a\u9ad8\u6548\u7684\u5efa\u5806\u65b9\u6cd5\uff0c\u5171\u5206\u4e3a\u4e24\u6b65\u3002

    1. \u5c06\u5217\u8868\u6240\u6709\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u5730\u6dfb\u52a0\u5230\u5806\u4e2d\uff0c\u6b64\u65f6\u5806\u7684\u6027\u8d28\u5c1a\u672a\u5f97\u5230\u6ee1\u8db3\u3002
    2. \u5012\u5e8f\u904d\u5386\u5806\uff08\u5c42\u5e8f\u904d\u5386\u7684\u5012\u5e8f\uff09\uff0c\u4f9d\u6b21\u5bf9\u6bcf\u4e2a\u975e\u53f6\u8282\u70b9\u6267\u884c\u201c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u201d\u3002

    \u6bcf\u5f53\u5806\u5316\u4e00\u4e2a\u8282\u70b9\u540e\uff0c\u4ee5\u8be5\u8282\u70b9\u4e3a\u6839\u8282\u70b9\u7684\u5b50\u6811\u5c31\u5f62\u6210\u4e00\u4e2a\u5408\u6cd5\u7684\u5b50\u5806\u3002\u800c\u7531\u4e8e\u662f\u5012\u5e8f\u904d\u5386\uff0c\u56e0\u6b64\u5806\u662f\u201c\u81ea\u4e0b\u800c\u4e0a\u201d\u6784\u5efa\u7684\u3002

    \u4e4b\u6240\u4ee5\u9009\u62e9\u5012\u5e8f\u904d\u5386\uff0c\u662f\u56e0\u4e3a\u8fd9\u6837\u80fd\u591f\u4fdd\u8bc1\u5f53\u524d\u8282\u70b9\u4e4b\u4e0b\u7684\u5b50\u6811\u5df2\u7ecf\u662f\u5408\u6cd5\u7684\u5b50\u5806\uff0c\u8fd9\u6837\u5806\u5316\u5f53\u524d\u8282\u70b9\u624d\u662f\u6709\u6548\u7684\u3002

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\u7531\u4e8e\u53f6\u8282\u70b9\u6ca1\u6709\u5b50\u8282\u70b9\uff0c\u56e0\u6b64\u5b83\u4eec\u5929\u7136\u5c31\u662f\u5408\u6cd5\u7684\u5b50\u5806\uff0c\u65e0\u987b\u5806\u5316\u3002\u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\uff0c\u6700\u540e\u4e00\u4e2a\u975e\u53f6\u8282\u70b9\u662f\u6700\u540e\u4e00\u4e2a\u8282\u70b9\u7684\u7236\u8282\u70b9\uff0c\u6211\u4eec\u4ece\u5b83\u5f00\u59cb\u5012\u5e8f\u904d\u5386\u5e76\u6267\u884c\u5806\u5316\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    self.max_heap = nums\n    # \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in range(self.parent(self.size() - 1), -1, -1):\n        self.sift_down(i)\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\n    maxHeap = nums;\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (int i = parent(size() - 1); i >= 0; i--) {\n        siftDown(i);\n    }\n}\n
    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\n    maxHeap = new ArrayList<>(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (int i = parent(size() - 1); i >= 0; i--) {\n        siftDown(i);\n    }\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\n    maxHeap = new List<int>(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    var size = Parent(this.Size() - 1);\n    for (int i = size; i >= 0; i--) {\n        SiftDown(i);\n    }\n}\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\n    h := &maxHeap{data: nums}\n    for i := h.parent(len(h.data) - 1); i >= 0; i-- {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        h.siftDown(i)\n    }\n    return h\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\n    maxHeap = nums\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in (0 ... parent(i: size() - 1)).reversed() {\n        siftDown(i: i)\n    }\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\n    this.#maxHeap = nums === undefined ? [] : [...nums];\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (let i = this.#parent(this.size() - 1); i >= 0; i--) {\n        this.#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\n    this.maxHeap = nums === undefined ? [] : [...nums];\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (let i = this.parent(this.size() - 1); i >= 0; i--) {\n        this.siftDown(i);\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\n  for (int i = _parent(size() - 1); i >= 0; i--) {\n    siftDown(i);\n  }\n}\n
    my_heap.rs
    /* \u6784\u9020\u65b9\u6cd5\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\nfn new(nums: Vec<i32>) -> Self {\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    let mut heap = MaxHeap { max_heap: nums };\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in (0..=Self::parent(heap.size() - 1)).rev() {\n        heap.sift_down(i);\n    }\n    heap\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\n    MaxHeap *maxHeap = (MaxHeap *)malloc(sizeof(MaxHeap));\n    maxHeap->size = size;\n    memcpy(maxHeap->data, nums, size * sizeof(int));\n    for (int i = parent(maxHeap, size - 1); i >= 0; i--) {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        siftDown(maxHeap, i);\n    }\n    return maxHeap;\n}\n
    my_heap.kt
    /* \u5927\u9876\u5806 */\nclass MaxHeap(nums: List<Int>?) {\n    // \u4f7f\u7528\u5217\u8868\u800c\u975e\u6570\u7ec4\uff0c\u8fd9\u6837\u65e0\u987b\u8003\u8651\u6269\u5bb9\u95ee\u9898\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    private val maxHeap = ArrayList(nums!!)\n\n    /* \u6784\u9020\u51fd\u6570\uff0c\u6839\u636e\u8f93\u5165\u5217\u8868\u5efa\u5806 */\n    init {\n        // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n        for (i in parent(size() - 1) downTo 0) {\n            siftDown(i)\n        }\n    }\n\n    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    private fun parent(i: Int): Int {\n        return (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u4ea4\u6362\u5143\u7d20 */\n    private fun swap(i: Int, j: Int) {\n        maxHeap[i] = maxHeap[j].also { maxHeap[j] = maxHeap[i] }\n    }\n\n    /* \u83b7\u53d6\u5806\u5927\u5c0f */\n    fun size(): Int {\n        return maxHeap.size\n    }\n\n    /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n        return size() == 0\n    }\n\n    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\n    fun peek(): Int {\n        return maxHeap[0]\n    }\n\n    /* \u5143\u7d20\u5165\u5806 */\n    fun push(value: Int) {\n        // \u6dfb\u52a0\u8282\u70b9\n        maxHeap.add(value)\n        // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n        siftUp(size() - 1)\n    }\n\n    /* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\n    private fun siftUp(it: Int) {\n        // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n        var i = it\n        while (true) {\n            // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n            val p = parent(i)\n            // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n            if (p < 0 || maxHeap[i] <= maxHeap[p]) break\n            // \u4ea4\u6362\u4e24\u8282\u70b9\n            swap(i, p)\n            // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n            i = p\n        }\n    }\n\n    /* \u5143\u7d20\u51fa\u5806 */\n    fun pop(): Int {\n        // \u5224\u7a7a\u5904\u7406\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        swap(0, size() - 1)\n        // \u5220\u9664\u8282\u70b9\n        val value = maxHeap.removeAt(size() - 1)\n        // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n        siftDown(0)\n        // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n        return value\n    }\n\n    /* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\n    private fun siftDown(it: Int) {\n        // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n        var i = it\n        while (true) {\n            // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n            val l = left(i)\n            val r = right(i)\n            var ma = i\n            if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l\n            if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r\n            // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n            if (ma == i) break\n            // \u4ea4\u6362\u4e24\u8282\u70b9\n            swap(i, ma)\n            // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n            i = ma\n        }\n    }\n\n    /* \u6253\u5370\u5806\uff08\u4e8c\u53c9\u6811\uff09 */\n    fun print() {\n        val queue = PriorityQueue { a: Int, b: Int -> b - a }\n        queue.addAll(maxHeap)\n        printHeap(queue)\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{__init__}\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 {\n    if (self.max_heap != null) return;\n    self.max_heap = std.ArrayList(T).init(allocator);\n    // \u5c06\u5217\u8868\u5143\u7d20\u539f\u5c01\u4e0d\u52a8\u6dfb\u52a0\u8fdb\u5806\n    try self.max_heap.?.appendSlice(nums);\n    // \u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    var i: usize = parent(self.size() - 1) + 1;\n    while (i > 0) : (i -= 1) {\n        try self.siftDown(i - 1);\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_heap/build_heap/#823","title":"8.2.3 \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"

    \u4e0b\u9762\uff0c\u6211\u4eec\u6765\u5c1d\u8bd5\u63a8\u7b97\u7b2c\u4e8c\u79cd\u5efa\u5806\u65b9\u6cd5\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u3002

    • \u5047\u8bbe\u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\(n\\) \uff0c\u5219\u53f6\u8282\u70b9\u6570\u91cf\u4e3a \\((n + 1) / 2\\) \uff0c\u5176\u4e2d \\(/\\) \u4e3a\u5411\u4e0b\u6574\u9664\u3002\u56e0\u6b64\u9700\u8981\u5806\u5316\u7684\u8282\u70b9\u6570\u91cf\u4e3a \\((n - 1) / 2\\) \u3002
    • \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 \\(\\log n\\) \u3002

    \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\u4f46\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\u6027\u8d28\u3002

    \u63a5\u4e0b\u6765\u6211\u4eec\u6765\u8fdb\u884c\u66f4\u4e3a\u51c6\u786e\u7684\u8ba1\u7b97\u3002\u4e3a\u4e86\u964d\u4f4e\u8ba1\u7b97\u96be\u5ea6\uff0c\u5047\u8bbe\u7ed9\u5b9a\u4e00\u4e2a\u8282\u70b9\u6570\u91cf\u4e3a \\(n\\) \u3001\u9ad8\u5ea6\u4e3a \\(h\\) \u7684\u201c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u201d\uff0c\u8be5\u5047\u8bbe\u4e0d\u4f1a\u5f71\u54cd\u8ba1\u7b97\u7ed3\u679c\u7684\u6b63\u786e\u6027\u3002

    \u56fe 8-5 \u00a0 \u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u5404\u5c42\u8282\u70b9\u6570\u91cf

    \u5982\u56fe 8-5 \u6240\u793a\uff0c\u8282\u70b9\u201c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u201d\u7684\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\u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u5bf9\u5404\u5c42\u7684\u201c\u8282\u70b9\u6570\u91cf \\(\\times\\) \u8282\u70b9\u9ad8\u5ea6\u201d\u6c42\u548c\uff0c\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) + \\dots + 2^{(h-1)}\\times1 \\]

    \u5316\u7b80\u4e0a\u5f0f\u9700\u8981\u501f\u52a9\u4e2d\u5b66\u7684\u6570\u5217\u77e5\u8bc6\uff0c\u5148\u5c06 \\(T(h)\\) \u4e58\u4ee5 \\(2\\) \uff0c\u5f97\u5230\uff1a

    \\[ \\begin{aligned} T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \\dots + 2^{h-1}\\times1 \\newline 2 T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \\dots + 2^{h}\\times1 \\newline \\end{aligned} \\]

    \u4f7f\u7528\u9519\u4f4d\u76f8\u51cf\u6cd5\uff0c\u7528\u4e0b\u5f0f \\(2 T(h)\\) \u51cf\u53bb\u4e0a\u5f0f \\(T(h)\\) \uff0c\u53ef\u5f97\uff1a

    \\[ 2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \\dots + 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\uff1a

    \\[ \\begin{aligned} T(h) & = 2 \\frac{1 - 2^h}{1 - 2} - h \\newline & = 2^{h+1} - h - 2 \\newline & = O(2^h) \\end{aligned} \\]

    \u8fdb\u4e00\u6b65\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\u4e3b\u8981\u53ef\u5206\u4e3a\u4e24\u79cd\u7c7b\u578b\uff0c\u5982\u56fe 8-1 \u6240\u793a\u3002

    • \u300c\u5c0f\u9876\u5806 min heap\u300d\uff1a\u4efb\u610f\u8282\u70b9\u7684\u503c \\(\\leq\\) \u5176\u5b50\u8282\u70b9\u7684\u503c\u3002
    • \u300c\u5927\u9876\u5806 max heap\u300d\uff1a\u4efb\u610f\u8282\u70b9\u7684\u503c \\(\\geq\\) \u5176\u5b50\u8282\u70b9\u7684\u503c\u3002

    \u56fe 8-1 \u00a0 \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\u3002

    • \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\u201c\u5806\u9876\u201d\uff0c\u5c06\u5e95\u5c42\u6700\u9760\u53f3\u7684\u8282\u70b9\u79f0\u4e3a\u201c\u5806\u5e95\u201d\u3002
    • \u5bf9\u4e8e\u5927\u9876\u5806\uff08\u5c0f\u9876\u5806\uff09\uff0c\u5806\u9876\u5143\u7d20\uff08\u6839\u8282\u70b9\uff09\u7684\u503c\u662f\u6700\u5927\uff08\u6700\u5c0f\uff09\u7684\u3002
    "},{"location":"chapter_heap/heap/#811","title":"8.1.1 \u00a0 \u5806\u7684\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\u7684\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\u4e8e\u5b9e\u73b0\u4f18\u5148\u961f\u5217\uff0c\u5927\u9876\u5806\u76f8\u5f53\u4e8e\u5143\u7d20\u6309\u4ece\u5927\u5230\u5c0f\u7684\u987a\u5e8f\u51fa\u961f\u7684\u4f18\u5148\u961f\u5217\u3002\u4ece\u4f7f\u7528\u89d2\u5ea6\u6765\u770b\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u201c\u4f18\u5148\u961f\u5217\u201d\u548c\u201c\u5806\u201d\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\u79f0\u4f5c\u201c\u5806\u201d\u3002

    \u5806\u7684\u5e38\u7528\u64cd\u4f5c\u89c1\u8868 8-1 \uff0c\u65b9\u6cd5\u540d\u9700\u8981\u6839\u636e\u7f16\u7a0b\u8bed\u8a00\u6765\u786e\u5b9a\u3002

    \u8868 8-1 \u00a0 \u5806\u7684\u64cd\u4f5c\u6548\u7387

    \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\u5bf9\u4e8e\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

    \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\u8bbe\u7f6e\u4e00\u4e2a flag \u6216\u4fee\u6539 Comparator \u5b9e\u73b0\u201c\u5c0f\u9876\u5806\u201d\u4e0e\u201c\u5927\u9876\u5806\u201d\u4e4b\u95f4\u7684\u8f6c\u6362\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig heap.py
    # \u521d\u59cb\u5316\u5c0f\u9876\u5806\nmin_heap, flag = [], 1\n# \u521d\u59cb\u5316\u5927\u9876\u5806\nmax_heap, flag = [], -1\n\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\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\n# \u83b7\u53d6\u5806\u9876\u5143\u7d20\npeek: int = flag * max_heap[0] # 5\n\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\n# \u83b7\u53d6\u5806\u5927\u5c0f\nsize: int = len(max_heap)\n\n# \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = not max_heap\n\n# \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806\nmin_heap: list[int] = [1, 3, 2, 5, 4]\nheapq.heapify(min_heap)\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\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.push(1);\nmaxHeap.push(3);\nmaxHeap.push(2);\nmaxHeap.push(5);\nmaxHeap.push(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.top(); // 5\n\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\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.empty();\n\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.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\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.offer(1);\nmaxHeap.offer(3);\nmaxHeap.offer(2);\nmaxHeap.offer(5);\nmaxHeap.offer(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.peek(); // 5\n\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.poll(); // 5\npeek = maxHeap.poll(); // 4\npeek = maxHeap.poll(); // 3\npeek = maxHeap.poll(); // 2\npeek = maxHeap.poll(); // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.size();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = maxHeap.isEmpty();\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<>(Arrays.asList(1, 3, 2, 5, 4));\n
    heap.cs
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nPriorityQueue<int, int> minHeap = new();\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(Comparer<int>.Create((x, y) => y - x));\n\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\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nint peek = maxHeap.Peek();//5\n\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\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nint size = maxHeap.Count;\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = maxHeap.Count == 0;\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = new PriorityQueue<int, int>([(1, 1), (3, 3), (2, 2), (5, 5), (4, 4)]);\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\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\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\n    last := (*h)[len(*h)-1]\n    *h = (*h)[:len(*h)-1]\n    return last\n}\n\n// Len sort.Interface \u7684\u65b9\u6cd5\nfunc (h *intHeap) Len() int {\n    return len(*h)\n}\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\n    return (*h)[i].(int) > (*h)[j].(int)\n}\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\n// Top \u83b7\u53d6\u5806\u9876\u5143\u7d20\nfunc (h *intHeap) Top() any {\n    return (*h)[0]\n}\n\n/* Driver Code */\nfunc TestHeap(t *testing.T) {\n    /* \u521d\u59cb\u5316\u5806 */\n    // \u521d\u59cb\u5316\u5927\u9876\u5806\n    maxHeap := &intHeap{}\n    heap.Init(maxHeap)\n    /* \u5143\u7d20\u5165\u5806 */\n    // \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u6dfb\u52a0\u5143\u7d20\n    heap.Push(maxHeap, 1)\n    heap.Push(maxHeap, 3)\n    heap.Push(maxHeap, 2)\n    heap.Push(maxHeap, 4)\n    heap.Push(maxHeap, 5)\n\n    /* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\n    top := maxHeap.Top()\n    fmt.Printf(\"\u5806\u9876\u5143\u7d20\u4e3a %d\\n\", top)\n\n    /* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n    // \u8c03\u7528 heap.Interface \u7684\u65b9\u6cd5\uff0c\u6765\u79fb\u9664\u5143\u7d20\n    heap.Pop(maxHeap) // 5\n    heap.Pop(maxHeap) // 4\n    heap.Pop(maxHeap) // 3\n    heap.Pop(maxHeap) // 2\n    heap.Pop(maxHeap) // 1\n\n    /* \u83b7\u53d6\u5806\u5927\u5c0f */\n    size := len(*maxHeap)\n    fmt.Printf(\"\u5806\u5143\u7d20\u6570\u91cf\u4e3a %d\\n\", size)\n\n    /* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\n    isEmpty := len(*maxHeap) == 0\n    fmt.Printf(\"\u5806\u662f\u5426\u4e3a\u7a7a %t\\n\", isEmpty)\n}\n
    heap.swift
    /* \u521d\u59cb\u5316\u5806 */\n// Swift \u7684 Heap \u7c7b\u578b\u540c\u65f6\u652f\u6301\u6700\u5927\u5806\u548c\u6700\u5c0f\u5806\uff0c\u4e14\u9700\u8981\u5f15\u5165 swift-collections\nvar heap = Heap<Int>()\n\n/* \u5143\u7d20\u5165\u5806 */\nheap.insert(1)\nheap.insert(3)\nheap.insert(2)\nheap.insert(5)\nheap.insert(4)\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nvar peek = heap.max()!\n\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\npeek = heap.removeMax() // 5\npeek = heap.removeMax() // 4\npeek = heap.removeMax() // 3\npeek = heap.removeMax() // 2\npeek = heap.removeMax() // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nlet size = heap.count\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = heap.isEmpty\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nlet heap2 = Heap([1, 3, 2, 5, 4])\n
    heap.js
    // JavaScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.ts
    // TypeScript \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.dart
    // Dart \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.rs
    use std::collections::BinaryHeap;\nuse std::cmp::Reverse;\n\n/* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nlet mut min_heap = BinaryHeap::<Reverse<i32>>::new();\n// \u521d\u59cb\u5316\u5927\u9876\u5806\nlet mut max_heap = BinaryHeap::new();\n\n/* \u5143\u7d20\u5165\u5806 */\nmax_heap.push(1);\nmax_heap.push(3);\nmax_heap.push(2);\nmax_heap.push(5);\nmax_heap.push(4);\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nlet peek = max_heap.peek().unwrap();  // 5\n\n/* \u5806\u9876\u5143\u7d20\u51fa\u5806 */\n// \u51fa\u5806\u5143\u7d20\u4f1a\u5f62\u6210\u4e00\u4e2a\u4ece\u5927\u5230\u5c0f\u7684\u5e8f\u5217\nlet peek = max_heap.pop().unwrap();   // 5\nlet peek = max_heap.pop().unwrap();   // 4\nlet peek = max_heap.pop().unwrap();   // 3\nlet peek = max_heap.pop().unwrap();   // 2\nlet peek = max_heap.pop().unwrap();   // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nlet size = max_heap.len();\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = max_heap.is_empty();\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nlet min_heap = BinaryHeap::from(vec![Reverse(1), Reverse(3), Reverse(2), Reverse(5), Reverse(4)]);\n
    heap.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e Heap \u7c7b\n
    heap.kt
    /* \u521d\u59cb\u5316\u5806 */\n// \u521d\u59cb\u5316\u5c0f\u9876\u5806\nvar minHeap = PriorityQueue<Int>()\n// \u521d\u59cb\u5316\u5927\u9876\u5806\uff08\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\u4fee\u6539 Comparator \u5373\u53ef\uff09\nval maxHeap = PriorityQueue { a: Int, b: Int -> b - a }\n\n/* \u5143\u7d20\u5165\u5806 */\nmaxHeap.offer(1)\nmaxHeap.offer(3)\nmaxHeap.offer(2)\nmaxHeap.offer(5)\nmaxHeap.offer(4)\n\n/* \u83b7\u53d6\u5806\u9876\u5143\u7d20 */\nvar peek = maxHeap.peek() // 5\n\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.poll() // 5\npeek = maxHeap.poll() // 4\npeek = maxHeap.poll() // 3\npeek = maxHeap.poll() // 2\npeek = maxHeap.poll() // 1\n\n/* \u83b7\u53d6\u5806\u5927\u5c0f */\nval size = maxHeap.size\n\n/* \u5224\u65ad\u5806\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = maxHeap.isEmpty()\n\n/* \u8f93\u5165\u5217\u8868\u5e76\u5efa\u5806 */\nminHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))\n
    heap.rb
    \n
    heap.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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":"1. \u00a0 \u5806\u7684\u5b58\u50a8\u4e0e\u8868\u793a","text":"

    \u201c\u4e8c\u53c9\u6811\u201d\u7ae0\u8282\u8bb2\u8fc7\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\u56e0\u6b64\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

    \u5982\u56fe 8-2 \u6240\u793a\uff0c\u7ed9\u5b9a\u7d22\u5f15 \\(i\\) \uff0c\u5176\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\u4e3a \\(2i + 1\\) \uff0c\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\u4e3a \\(2i + 2\\) \uff0c\u7236\u8282\u70b9\u7684\u7d22\u5f15\u4e3a \\((i - 1) / 2\\)\uff08\u5411\u4e0b\u6574\u9664\uff09\u3002\u5f53\u7d22\u5f15\u8d8a\u754c\u65f6\uff0c\u8868\u793a\u7a7a\u8282\u70b9\u6216\u8282\u70b9\u4e0d\u5b58\u5728\u3002

    \u56fe 8-2 \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def left(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return 2 * i + 1\n\ndef right(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return 2 * i + 2\n\ndef parent(self, i: int) -> int:\n    \"\"\"\u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n    return (i - 1) // 2  # \u5411\u4e0b\u6574\u9664\n
    my_heap.cpp
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.java
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.cs
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint Left(int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint Right(int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint Parent(int i) {\n    return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.go
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) left(i int) int {\n    return 2*i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) right(i int) int {\n    return 2*i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (h *maxHeap) parent(i int) int {\n    // \u5411\u4e0b\u6574\u9664\n    return (i - 1) / 2\n}\n
    my_heap.swift
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc left(i: Int) -> Int {\n    2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc right(i: Int) -> Int {\n    2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc parent(i: Int) -> Int {\n    (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.js
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n#left(i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n#right(i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n#parent(i) {\n    return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.ts
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nleft(i: number): number {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nright(i: number): number {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nparent(i: number): number {\n    return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.dart
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint _left(int i) {\n  return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint _right(int i) {\n  return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint _parent(int i) {\n  return (i - 1) ~/ 2; // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.rs
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfn left(i: usize) -> usize {\n    2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfn right(i: usize) -> usize {\n    2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfn parent(i: usize) -> usize {\n    (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.c
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint left(MaxHeap *maxHeap, int i) {\n    return 2 * i + 1;\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nint right(MaxHeap *maxHeap, int i) {\n    return 2 * i + 2;\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nint parent(MaxHeap *maxHeap, int i) {\n    return (i - 1) / 2;\n}\n
    my_heap.kt
    /* \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfun left(i: Int): Int {\n    return 2 * i + 1\n}\n\n/* \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfun right(i: Int): Int {\n    return 2 * i + 2\n}\n\n/* \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfun parent(i: Int): Int {\n    return (i - 1) / 2 // \u5411\u4e0b\u6574\u9664\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{left}\n\n[class]{MaxHeap}-[func]{right}\n\n[class]{MaxHeap}-[func]{parent}\n
    my_heap.zig
    // \u83b7\u53d6\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\nfn left(i: usize) usize {\n    return 2 * i + 1;\n}\n\n// \u83b7\u53d6\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\nfn right(i: usize) usize {\n    return 2 * i + 2;\n}\n\n// \u83b7\u53d6\u7236\u8282\u70b9\u7684\u7d22\u5f15\nfn parent(i: usize) usize {\n    // return (i - 1) / 2; // \u5411\u4e0b\u6574\u9664\n    return @divFloor(i - 1, 2);\n}\n
    "},{"location":"chapter_heap/heap/#2","title":"2. \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def peek(self) -> int:\n    \"\"\"\u8bbf\u95ee\u5806\u9876\u5143\u7d20\"\"\"\n    return self.max_heap[0]\n
    my_heap.cpp
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n    return maxHeap[0];\n}\n
    my_heap.java
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n    return maxHeap.get(0);\n}\n
    my_heap.cs
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint Peek() {\n    return maxHeap[0];\n}\n
    my_heap.go
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc (h *maxHeap) peek() any {\n    return h.data[0]\n}\n
    my_heap.swift
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunc peek() -> Int {\n    maxHeap[0]\n}\n
    my_heap.js
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek() {\n    return this.#maxHeap[0];\n}\n
    my_heap.ts
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\npeek(): number {\n    return this.maxHeap[0];\n}\n
    my_heap.dart
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek() {\n  return _maxHeap[0];\n}\n
    my_heap.rs
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfn peek(&self) -> Option<i32> {\n    self.max_heap.first().copied()\n}\n
    my_heap.c
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peek(MaxHeap *maxHeap) {\n    return maxHeap->data[0];\n}\n
    my_heap.kt
    /* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfun peek(): Int {\n    return maxHeap[0]\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{peek}\n
    my_heap.zig
    // \u8bbf\u95ee\u5806\u9876\u5143\u7d20\nfn peek(self: *Self) T {\n    return self.max_heap.?.items[0];\n}  \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_heap/heap/#3","title":"3. \u00a0 \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\uff0c\u56e0\u6b64\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\u5982\u56fe 8-3 \u6240\u793a\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\u987b\u4ea4\u6362\u7684\u8282\u70b9\u65f6\u7ed3\u675f\u3002

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

    \u56fe 8-3 \u00a0 \u5143\u7d20\u5165\u5806\u6b65\u9aa4

    \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def push(self, val: int):\n    \"\"\"\u5143\u7d20\u5165\u5806\"\"\"\n    # \u6dfb\u52a0\u8282\u70b9\n    self.max_heap.append(val)\n    # \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    self.sift_up(self.size() - 1)\n\ndef sift_up(self, i: int):\n    \"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\"\"\"\n    while True:\n        # \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        p = self.parent(i)\n        # \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 or self.max_heap[i] <= self.max_heap[p]:\n            break\n        # \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, p)\n        # \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n
    my_heap.cpp
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(int val) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.push_back(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p])\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap[i], maxHeap[p]);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.java
    /* \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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.cs
    /* \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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid SiftUp(int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = Parent(i);\n        // \u82e5\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p])\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        Swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.go
    /* \u5143\u7d20\u5165\u5806 */\nfunc (h *maxHeap) push(val any) {\n    // \u6dfb\u52a0\u8282\u70b9\n    h.data = append(h.data, val)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    h.siftUp(len(h.data) - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc (h *maxHeap) siftUp(i int) {\n    for true {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        p := h.parent(i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 || h.data[i].(int) <= h.data[p].(int) {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        h.swap(i, p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.swift
    /* \u5143\u7d20\u5165\u5806 */\nfunc push(val: Int) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.append(val)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(i: size() - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfunc siftUp(i: Int) {\n    var i = i\n    while true {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        let p = parent(i: i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if p < 0 || maxHeap[i] <= maxHeap[p] {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i: i, j: p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.js
    /* \u5143\u7d20\u5165\u5806 */\npush(val) {\n    // \u6dfb\u52a0\u8282\u70b9\n    this.#maxHeap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    this.#siftUp(this.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\n#siftUp(i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        const p = this.#parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.#swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.ts
    /* \u5143\u7d20\u5165\u5806 */\npush(val: number): void {\n    // \u6dfb\u52a0\u8282\u70b9\n    this.maxHeap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    this.siftUp(this.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nsiftUp(i: number): void {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        const p = this.parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = 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\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(int i) {\n  while (true) {\n    // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n    int p = _parent(i);\n    // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n    if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {\n      break;\n    }\n    // \u4ea4\u6362\u4e24\u8282\u70b9\n    _swap(i, p);\n    // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n    i = p;\n  }\n}\n
    my_heap.rs
    /* \u5143\u7d20\u5165\u5806 */\nfn push(&mut self, val: i32) {\n    // \u6dfb\u52a0\u8282\u70b9\n    self.max_heap.push(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    self.sift_up(self.size() - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfn sift_up(&mut self, mut i: usize) {\n    loop {\n        // \u8282\u70b9 i \u5df2\u7ecf\u662f\u5806\u9876\u8282\u70b9\u4e86\uff0c\u7ed3\u675f\u5806\u5316\n        if i == 0 {\n            break;\n        }\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        let p = Self::parent(i);\n        // \u5f53\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if self.max_heap[i] <= self.max_heap[p] {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.c
    /* \u5143\u7d20\u5165\u5806 */\nvoid push(MaxHeap *maxHeap, int val) {\n    // \u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u4e0d\u5e94\u8be5\u6dfb\u52a0\u8fd9\u4e48\u591a\u8282\u70b9\n    if (maxHeap->size == MAX_SIZE) {\n        printf(\"heap is full!\");\n        return;\n    }\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap->data[maxHeap->size] = val;\n    maxHeap->size++;\n\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(maxHeap, maxHeap->size - 1);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nvoid siftUp(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        int p = parent(maxHeap, i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap->data[i] <= maxHeap->data[p]) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap, i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    my_heap.kt
    /* \u5143\u7d20\u5165\u5806 */\nfun push(value: Int) {\n    // \u6dfb\u52a0\u8282\u70b9\n    maxHeap.add(value)\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    siftUp(size() - 1)\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316 */\nfun siftUp(it: Int) {\n    // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n    var i = it\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        val p = parent(i)\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 || maxHeap[i] <= maxHeap[p]) break\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, p)\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{push}\n\n[class]{MaxHeap}-[func]{sift_up}\n
    my_heap.zig
    // \u5143\u7d20\u5165\u5806\nfn push(self: *Self, val: T) !void {\n    // \u6dfb\u52a0\u8282\u70b9\n    try self.max_heap.?.append(val);\n    // \u4ece\u5e95\u81f3\u9876\u5806\u5316\n    try self.siftUp(self.size() - 1);\n}  \n\n// \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u5e95\u81f3\u9876\u5806\u5316\nfn siftUp(self: *Self, i_: usize) !void {\n    var i = i_;\n    while (true) {\n        // \u83b7\u53d6\u8282\u70b9 i \u7684\u7236\u8282\u70b9\n        var p = parent(i);\n        // \u5f53\u201c\u8d8a\u8fc7\u6839\u8282\u70b9\u201d\u6216\u201c\u8282\u70b9\u65e0\u987b\u4fee\u590d\u201d\u65f6\uff0c\u7ed3\u675f\u5806\u5316\n        if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        try self.swap(i, p);\n        // \u5faa\u73af\u5411\u4e0a\u5806\u5316\n        i = p;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_heap/heap/#4","title":"4. \u00a0 \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\u8fdb\u884c\u4fee\u590d\u53d8\u5f97\u56f0\u96be\u3002\u4e3a\u4e86\u5c3d\u91cf\u51cf\u5c11\u5143\u7d20\u7d22\u5f15\u7684\u53d8\u52a8\uff0c\u6211\u4eec\u91c7\u7528\u4ee5\u4e0b\u64cd\u4f5c\u6b65\u9aa4\u3002

    1. \u4ea4\u6362\u5806\u9876\u5143\u7d20\u4e0e\u5806\u5e95\u5143\u7d20\uff08\u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff09\u3002
    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\u56e0\u6b64\u5b9e\u9645\u4e0a\u5220\u9664\u7684\u662f\u539f\u6765\u7684\u5806\u9876\u5143\u7d20\uff09\u3002
    3. \u4ece\u6839\u8282\u70b9\u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u6267\u884c\u5806\u5316\u3002

    \u5982\u56fe 8-4 \u6240\u793a\uff0c\u201c\u4ece\u9876\u81f3\u5e95\u5806\u5316\u201d\u7684\u64cd\u4f5c\u65b9\u5411\u4e0e\u201c\u4ece\u5e95\u81f3\u9876\u5806\u5316\u201d\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\u3002\u7136\u540e\u5faa\u73af\u6267\u884c\u6b64\u64cd\u4f5c\uff0c\u76f4\u5230\u8d8a\u8fc7\u53f6\u8282\u70b9\u6216\u9047\u5230\u65e0\u987b\u4ea4\u6362\u7684\u8282\u70b9\u65f6\u7ed3\u675f\u3002

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

    \u56fe 8-4 \u00a0 \u5806\u9876\u5143\u7d20\u51fa\u5806\u6b65\u9aa4

    \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig my_heap.py
    def pop(self) -> int:\n    \"\"\"\u5143\u7d20\u51fa\u5806\"\"\"\n    # \u5224\u7a7a\u5904\u7406\n    if self.is_empty():\n        raise IndexError(\"\u5806\u4e3a\u7a7a\")\n    # \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    self.swap(0, self.size() - 1)\n    # \u5220\u9664\u8282\u70b9\n    val = self.max_heap.pop()\n    # \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    self.sift_down(0)\n    # \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n\ndef sift_down(self, i: int):\n    \"\"\"\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\"\"\"\n    while True:\n        # \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        l, r, ma = self.left(i), self.right(i), i\n        if l < self.size() and self.max_heap[l] > self.max_heap[ma]:\n            ma = l\n        if r < self.size() and self.max_heap[r] > self.max_heap[ma]:\n            ma = r\n        # \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i:\n            break\n        # \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, ma)\n        # \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n
    my_heap.cpp
    /* \u5143\u7d20\u51fa\u5806 */\nvoid pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty()) {\n        throw out_of_range(\"\u5806\u4e3a\u7a7a\");\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(maxHeap[0], maxHeap[size() - 1]);\n    // \u5220\u9664\u8282\u70b9\n    maxHeap.pop_back();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0);\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = left(i), r = right(i), ma = i;\n        if (l < size() && maxHeap[l] > maxHeap[ma])\n            ma = l;\n        if (r < size() && maxHeap[r] > maxHeap[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        swap(maxHeap[i], maxHeap[ma]);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.java
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty())\n        throw new IndexOutOfBoundsException();\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(0, size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap.remove(size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = left(i), r = right(i), ma = i;\n        if (l < size() && maxHeap.get(l) > maxHeap.get(ma))\n            ma = l;\n        if (r < size() && maxHeap.get(r) > maxHeap.get(ma))\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.cs
    /* \u5143\u7d20\u51fa\u5806 */\nint Pop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (IsEmpty())\n        throw new IndexOutOfRangeException();\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    Swap(0, Size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap.Last();\n    maxHeap.RemoveAt(Size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    SiftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid SiftDown(int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = Left(i), r = Right(i), ma = i;\n        if (l < Size() && maxHeap[l] > maxHeap[ma])\n            ma = l;\n        if (r < Size() && maxHeap[r] > maxHeap[ma])\n            ma = r;\n        // \u82e5\u201c\u8282\u70b9 i \u6700\u5927\u201d\u6216\u201c\u8d8a\u8fc7\u53f6\u8282\u70b9\u201d\uff0c\u5219\u7ed3\u675f\u5806\u5316\n        if (ma == i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        Swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.go
    /* \u5143\u7d20\u51fa\u5806 */\nfunc (h *maxHeap) pop() any {\n    // \u5224\u7a7a\u5904\u7406\n    if h.isEmpty() {\n        fmt.Println(\"error\")\n        return nil\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    h.swap(0, h.size()-1)\n    // \u5220\u9664\u8282\u70b9\n    val := h.data[len(h.data)-1]\n    h.data = h.data[:len(h.data)-1]\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    h.siftDown(0)\n\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc (h *maxHeap) siftDown(i int) {\n    for true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\n        l, r, max := h.left(i), h.right(i), i\n        if l < h.size() && h.data[l].(int) > h.data[max].(int) {\n            max = l\n        }\n        if r < h.size() && h.data[r].(int) > h.data[max].(int) {\n            max = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if max == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        h.swap(i, max)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = max\n    }\n}\n
    my_heap.swift
    /* \u5143\u7d20\u51fa\u5806 */\nfunc pop() -> Int {\n    // \u5224\u7a7a\u5904\u7406\n    if isEmpty() {\n        fatalError(\"\u5806\u4e3a\u7a7a\")\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(i: 0, j: size() - 1)\n    // \u5220\u9664\u8282\u70b9\n    let val = maxHeap.remove(at: size() - 1)\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(i: 0)\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfunc siftDown(i: Int) {\n    var i = i\n    while true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = left(i: i)\n        let r = right(i: i)\n        var ma = i\n        if l < size(), maxHeap[l] > maxHeap[ma] {\n            ma = l\n        }\n        if r < size(), maxHeap[r] > maxHeap[ma] {\n            ma = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i: i, j: ma)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\n}\n
    my_heap.js
    /* \u5143\u7d20\u51fa\u5806 */\npop() {\n    // \u5224\u7a7a\u5904\u7406\n    if (this.isEmpty()) throw new Error('\u5806\u4e3a\u7a7a');\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    this.#swap(0, this.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    const val = this.#maxHeap.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    this.#siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\n#siftDown(i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        const l = this.#left(i),\n            r = this.#right(i);\n        let ma = i;\n        if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.#swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.ts
    /* \u5143\u7d20\u51fa\u5806 */\npop(): number {\n    // \u5224\u7a7a\u5904\u7406\n    if (this.isEmpty()) throw new RangeError('Heap is empty.');\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    this.swap(0, this.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    const val = this.maxHeap.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    this.siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nsiftDown(i: number): void {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        const l = this.left(i),\n            r = this.right(i);\n        let ma = i;\n        if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        this.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.dart
    /* \u5143\u7d20\u51fa\u5806 */\nint pop() {\n  // \u5224\u7a7a\u5904\u7406\n  if (isEmpty()) throw Exception('\u5806\u4e3a\u7a7a');\n  // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n  _swap(0, size() - 1);\n  // \u5220\u9664\u8282\u70b9\n  int val = _maxHeap.removeLast();\n  // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n  siftDown(0);\n  // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n  return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(int i) {\n  while (true) {\n    // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n    int l = _left(i);\n    int r = _right(i);\n    int ma = i;\n    if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;\n    if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;\n    // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n    if (ma == i) break;\n    // \u4ea4\u6362\u4e24\u8282\u70b9\n    _swap(i, ma);\n    // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n    i = ma;\n  }\n}\n
    my_heap.rs
    /* \u5143\u7d20\u51fa\u5806 */\nfn pop(&mut self) -> i32 {\n    // \u5224\u7a7a\u5904\u7406\n    if self.is_empty() {\n        panic!(\"index out of bounds\");\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    self.swap(0, self.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    let val = self.max_heap.remove(self.size() - 1);\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    self.sift_down(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    val\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfn sift_down(&mut self, mut i: usize) {\n    loop {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let (l, r, mut ma) = (Self::left(i), Self::right(i), i);\n        if l < self.size() && self.max_heap[l] > self.max_heap[ma] {\n            ma = l;\n        }\n        if r < self.size() && self.max_heap[r] > self.max_heap[ma] {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        self.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    my_heap.c
    /* \u5143\u7d20\u51fa\u5806 */\nint pop(MaxHeap *maxHeap) {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty(maxHeap)) {\n        printf(\"heap is empty!\");\n        return INT_MAX;\n    }\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(maxHeap, 0, size(maxHeap) - 1);\n    // \u5220\u9664\u8282\u70b9\n    int val = maxHeap->data[maxHeap->size - 1];\n    maxHeap->size--;\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(maxHeap, 0);\n\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nvoid siftDown(MaxHeap *maxHeap, int i) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a max\n        int l = left(maxHeap, i);\n        int r = right(maxHeap, i);\n        int max = i;\n        if (l < size(maxHeap) && maxHeap->data[l] > maxHeap->data[max]) {\n            max = l;\n        }\n        if (r < size(maxHeap) && maxHeap->data[r] > maxHeap->data[max]) {\n            max = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (max == i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(maxHeap, i, max);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = max;\n    }\n}\n
    my_heap.kt
    /* \u5143\u7d20\u51fa\u5806 */\nfun pop(): Int {\n    // \u5224\u7a7a\u5904\u7406\n    if (isEmpty()) throw IndexOutOfBoundsException()\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    swap(0, size() - 1)\n    // \u5220\u9664\u8282\u70b9\n    val value = maxHeap.removeAt(size() - 1)\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    siftDown(0)\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return value\n}\n\n/* \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfun siftDown(it: Int) {\n    // Kotlin\u7684\u51fd\u6570\u53c2\u6570\u4e0d\u53ef\u53d8\uff0c\u56e0\u6b64\u521b\u5efa\u4e34\u65f6\u53d8\u91cf\n    var i = it\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        val l = left(i)\n        val r = right(i)\n        var ma = i\n        if (l < size() && maxHeap[l] > maxHeap[ma]) ma = l\n        if (r < size() && maxHeap[r] > maxHeap[ma]) ma = r\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) break\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(i, ma)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\n}\n
    my_heap.rb
    [class]{MaxHeap}-[func]{pop}\n\n[class]{MaxHeap}-[func]{sift_down}\n
    my_heap.zig
    // \u5143\u7d20\u51fa\u5806\nfn pop(self: *Self) !T {\n    // \u5224\u65ad\u5904\u7406\n    if (self.isEmpty()) unreachable;\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    try self.swap(0, self.size() - 1);\n    // \u5220\u9664\u8282\u70b9\n    var val = self.max_heap.?.pop();\n    // \u4ece\u9876\u81f3\u5e95\u5806\u5316\n    try self.siftDown(0);\n    // \u8fd4\u56de\u5806\u9876\u5143\u7d20\n    return val;\n} \n\n// \u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316\nfn siftDown(self: *Self, i_: usize) !void {\n    var i = i_;\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        var l = left(i);\n        var r = right(i);\n        var ma = i;\n        if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        try self.swap(i, ma);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_heap/heap/#813","title":"8.1.3 \u00a0 \u5806\u7684\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\u201c\u5806\u6392\u5e8f\u201d\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":""},{"location":"chapter_heap/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u201c\u5806\u201d\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\u6f0f\u3002\u76f8\u8f83\u4e8e\u6808\u5185\u5b58\uff0c\u5806\u5185\u5b58\u7684\u7ba1\u7406\u548c\u4f7f\u7528\u9700\u8981\u66f4\u8c28\u614e\uff0c\u4f7f\u7528\u4e0d\u5f53\u53ef\u80fd\u4f1a\u5bfc\u81f4\u5185\u5b58\u6cc4\u6f0f\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\\) \u7684\u65e0\u5e8f\u6570\u7ec4 nums \uff0c\u8bf7\u8fd4\u56de\u6570\u7ec4\u4e2d\u6700\u5927\u7684 \\(k\\) \u4e2a\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\u56fe 8-6 \u6240\u793a\u7684 \\(k\\) \u8f6e\u904d\u5386\uff0c\u5206\u522b\u5728\u6bcf\u8f6e\u4e2d\u63d0\u53d6\u7b2c \\(1\\)\u3001\\(2\\)\u3001\\(\\dots\\)\u3001\\(k\\) \u5927\u7684\u5143\u7d20\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(nk)\\) \u3002

    \u6b64\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

    \u56fe 8-6 \u00a0 \u904d\u5386\u5bfb\u627e\u6700\u5927\u7684 k \u4e2a\u5143\u7d20

    Tip

    \u5f53 \\(k = n\\) \u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u5230\u5b8c\u6574\u7684\u6709\u5e8f\u5e8f\u5217\uff0c\u6b64\u65f6\u7b49\u4ef7\u4e8e\u201c\u9009\u62e9\u6392\u5e8f\u201d\u7b97\u6cd5\u3002

    "},{"location":"chapter_heap/top_k/#832","title":"8.3.2 \u00a0 \u65b9\u6cd5\u4e8c\uff1a\u6392\u5e8f","text":"

    \u5982\u56fe 8-7 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5148\u5bf9\u6570\u7ec4 nums \u8fdb\u884c\u6392\u5e8f\uff0c\u518d\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\u627e\u51fa\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\u5373\u53ef\uff0c\u800c\u4e0d\u9700\u8981\u6392\u5e8f\u5176\u4ed6\u5143\u7d20\u3002

    \u56fe 8-7 \u00a0 \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\u56fe 8-8 \u6240\u793a\u3002

    1. \u521d\u59cb\u5316\u4e00\u4e2a\u5c0f\u9876\u5806\uff0c\u5176\u5806\u9876\u5143\u7d20\u6700\u5c0f\u3002
    2. \u5148\u5c06\u6570\u7ec4\u7684\u524d \\(k\\) \u4e2a\u5143\u7d20\u4f9d\u6b21\u5165\u5806\u3002
    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\u3002
    4. \u904d\u5386\u5b8c\u6210\u540e\uff0c\u5806\u4e2d\u4fdd\u5b58\u7684\u5c31\u662f\u6700\u5927\u7684 \\(k\\) \u4e2a\u5143\u7d20\u3002
    <1><2><3><4><5><6><7><8><9>

    \u56fe 8-8 \u00a0 \u57fa\u4e8e\u5806\u5bfb\u627e\u6700\u5927\u7684 k \u4e2a\u5143\u7d20

    \u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    # \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    heap = []\n    # \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for i in range(k):\n        heapq.heappush(heap, nums[i])\n    # \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for 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\n        if nums[i] > heap[0]:\n            heapq.heappop(heap)\n            heapq.heappush(heap, nums[i])\n    return heap\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) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    priority_queue<int, vector<int>, greater<int>> heap;\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.push(nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.top()) {\n            heap.pop();\n            heap.push(nums[i]);\n        }\n    }\n    return heap;\n}\n
    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) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    Queue<Integer> heap = new PriorityQueue<Integer>();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.offer(nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.peek()) {\n            heap.poll();\n            heap.offer(nums[i]);\n        }\n    }\n    return heap;\n}\n
    top_k.cs
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nPriorityQueue<int, int> TopKHeap(int[] nums, int k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    PriorityQueue<int, int> heap = new();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        heap.Enqueue(nums[i], nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (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\n        if (nums[i] > heap.Peek()) {\n            heap.Dequeue();\n            heap.Enqueue(nums[i], nums[i]);\n        }\n    }\n    return heap;\n}\n
    top_k.go
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunc topKHeap(nums []int, k int) *minHeap {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    h := &minHeap{}\n    heap.Init(h)\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for i := 0; i < k; i++ {\n        heap.Push(h, nums[i])\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for i := k; i < len(nums); 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\n        if nums[i] > h.Top().(int) {\n            heap.Pop(h)\n            heap.Push(h, nums[i])\n        }\n    }\n    return h\n}\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    // \u521d\u59cb\u5316\u4e00\u4e2a\u5c0f\u9876\u5806\uff0c\u5e76\u5c06\u524d k \u4e2a\u5143\u7d20\u5efa\u5806\n    var heap = Heap(nums.prefix(k))\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for i in nums.indices.dropFirst(k) {\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\n        if nums[i] > heap.min()! {\n            _ = heap.removeMin()\n            heap.insert(nums[i])\n        }\n    }\n    return heap.unordered\n}\n
    top_k.js
    /* \u5143\u7d20\u5165\u5806 */\nfunction pushMinHeap(maxHeap, val) {\n    // \u5143\u7d20\u53d6\u53cd\n    maxHeap.push(-val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nfunction popMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.pop();\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunction peekMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.peek();\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nfunction getMinHeap(maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return maxHeap.getMaxHeap().map((num) => -num);\n}\n\n/* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunction topKHeap(nums, k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    const maxHeap = new MaxHeap([]);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (let i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (let 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // \u8fd4\u56de\u5806\u4e2d\u5143\u7d20\n    return getMinHeap(maxHeap);\n}\n
    top_k.ts
    /* \u5143\u7d20\u5165\u5806 */\nfunction pushMinHeap(maxHeap: MaxHeap, val: number): void {\n    // \u5143\u7d20\u53d6\u53cd\n    maxHeap.push(-val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nfunction popMinHeap(maxHeap: MaxHeap): number {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.pop();\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nfunction peekMinHeap(maxHeap: MaxHeap): number {\n    // \u5143\u7d20\u53d6\u53cd\n    return -maxHeap.peek();\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nfunction getMinHeap(maxHeap: MaxHeap): number[] {\n    // \u5143\u7d20\u53d6\u53cd\n    return maxHeap.getMaxHeap().map((num: number) => -num);\n}\n\n/* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfunction topKHeap(nums: number[], k: number): number[] {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    const maxHeap = new MaxHeap([]);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (let i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (let 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    // \u8fd4\u56de\u5806\u4e2d\u5143\u7d20\n    return getMinHeap(maxHeap);\n}\n
    top_k.dart
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nMinHeap topKHeap(List<int> nums, int k) {\n  // \u521d\u59cb\u5316\u5c0f\u9876\u5806\uff0c\u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n  MinHeap heap = MinHeap(nums.sublist(0, k));\n  // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n  for (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\n    if (nums[i] > heap.peek()) {\n      heap.pop();\n      heap.push(nums[i]);\n    }\n  }\n  return heap;\n}\n
    top_k.rs
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {\n    // BinaryHeap \u662f\u5927\u9876\u5806\uff0c\u4f7f\u7528 Reverse \u5c06\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u5b9e\u73b0\u5c0f\u9876\u5806\n    let mut heap = BinaryHeap::<Reverse<i32>>::new();\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for &num in nums.iter().take(k) {\n        heap.push(Reverse(num));\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for &num in nums.iter().skip(k) {\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\n        if num > heap.peek().unwrap().0 {\n            heap.pop();\n            heap.push(Reverse(num));\n        }\n    }\n    heap\n}\n
    top_k.c
    /* \u5143\u7d20\u5165\u5806 */\nvoid pushMinHeap(MaxHeap *maxHeap, int val) {\n    // \u5143\u7d20\u53d6\u53cd\n    push(maxHeap, -val);\n}\n\n/* \u5143\u7d20\u51fa\u5806 */\nint popMinHeap(MaxHeap *maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -pop(maxHeap);\n}\n\n/* \u8bbf\u95ee\u5806\u9876\u5143\u7d20 */\nint peekMinHeap(MaxHeap *maxHeap) {\n    // \u5143\u7d20\u53d6\u53cd\n    return -peek(maxHeap);\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // \u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\u5e76\u5b58\u5165 res \u6570\u7ec4\n    int *res = (int *)malloc(maxHeap->size * sizeof(int));\n    for (int i = 0; i < maxHeap->size; i++) {\n        res[i] = -maxHeap->data[i];\n    }\n    return res;\n}\n\n/* \u53d6\u51fa\u5806\u4e2d\u5143\u7d20 */\nint *getMinHeap(MaxHeap *maxHeap) {\n    // \u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\u5e76\u5b58\u5165 res \u6570\u7ec4\n    int *res = (int *)malloc(maxHeap->size * sizeof(int));\n    for (int i = 0; i < maxHeap->size; i++) {\n        res[i] = -maxHeap->data[i];\n    }\n    return res;\n}\n\n// \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20\u7684\u51fd\u6570\nint *topKHeap(int *nums, int sizeNums, int k) {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    // \u8bf7\u6ce8\u610f\uff1a\u6211\u4eec\u5c06\u5806\u4e2d\u6240\u6709\u5143\u7d20\u53d6\u53cd\uff0c\u4ece\u800c\u7528\u5927\u9876\u5806\u6765\u6a21\u62df\u5c0f\u9876\u5806\n    int *empty = (int *)malloc(0);\n    MaxHeap *maxHeap = newMaxHeap(empty, 0);\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (int i = 0; i < k; i++) {\n        pushMinHeap(maxHeap, nums[i]);\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (int i = k; i < sizeNums; 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\n        if (nums[i] > peekMinHeap(maxHeap)) {\n            popMinHeap(maxHeap);\n            pushMinHeap(maxHeap, nums[i]);\n        }\n    }\n    int *res = getMinHeap(maxHeap);\n    // \u91ca\u653e\u5185\u5b58\n    delMaxHeap(maxHeap);\n    return res;\n}\n
    top_k.kt
    /* \u57fa\u4e8e\u5806\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5927\u7684 k \u4e2a\u5143\u7d20 */\nfun topKHeap(nums: IntArray, k: Int): Queue<Int> {\n    // \u521d\u59cb\u5316\u5c0f\u9876\u5806\n    val heap = PriorityQueue<Int>()\n    // \u5c06\u6570\u7ec4\u7684\u524d k \u4e2a\u5143\u7d20\u5165\u5806\n    for (i in 0..<k) {\n        heap.offer(nums[i])\n    }\n    // \u4ece\u7b2c k+1 \u4e2a\u5143\u7d20\u5f00\u59cb\uff0c\u4fdd\u6301\u5806\u7684\u957f\u5ea6\u4e3a k\n    for (i in k..<nums.size) {\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\n        if (nums[i] > heap.peek()) {\n            heap.poll()\n            heap.offer(nums[i])\n        }\n    }\n    return heap\n}\n
    top_k.rb
    [class]{}-[func]{top_k_heap}\n
    top_k.zig
    [class]{}-[func]{topKHeap}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\u7684 \\(k\\) \u4e2a\u5143\u7d20\u7684\u52a8\u6001\u66f4\u65b0\u3002

    "},{"location":"chapter_introduction/","title":"\u7b2c 1 \u7ae0 \u00a0 \u521d\u8bc6\u7b97\u6cd5","text":"

    Abstract

    \u4e00\u4f4d\u5c11\u5973\u7fe9\u7fe9\u8d77\u821e\uff0c\u4e0e\u6570\u636e\u4ea4\u7ec7\u5728\u4e00\u8d77\uff0c\u88d9\u6446\u4e0a\u98d8\u626c\u7740\u7b97\u6cd5\u7684\u65cb\u5f8b\u3002

    \u5979\u9080\u8bf7\u4f60\u5171\u821e\uff0c\u8bf7\u7d27\u8ddf\u5979\u7684\u6b65\u4f10\uff0c\u8e0f\u5165\u5145\u6ee1\u903b\u8f91\u4e0e\u7f8e\u611f\u7684\u7b97\u6cd5\u4e16\u754c\u3002

    \u8ba1\u7b97\u673a\u7684\u51fa\u73b0\u7ed9\u4e16\u754c\u5e26\u6765\u4e86\u5de8\u5927\u53d8\u9769\uff0c\u5b83\u51ed\u501f\u9ad8\u901f\u7684\u8ba1\u7b97\u80fd\u529b\u548c\u51fa\u8272\u7684\u53ef\u7f16\u7a0b\u6027\uff0c\u6210\u4e3a\u4e86\u6267\u884c\u7b97\u6cd5\u4e0e\u5904\u7406\u6570\u636e\u7684\u7406\u60f3\u5a92\u4ecb\u3002\u65e0\u8bba\u662f\u7535\u5b50\u6e38\u620f\u7684\u903c\u771f\u753b\u9762\u3001\u81ea\u52a8\u9a7e\u9a76\u7684\u667a\u80fd\u51b3\u7b56\uff0c\u8fd8\u662f AlphaGo \u7684\u7cbe\u5f69\u68cb\u5c40\u3001ChatGPT \u7684\u81ea\u7136\u4ea4\u4e92\uff0c\u8fd9\u4e9b\u5e94\u7528\u90fd\u662f\u7b97\u6cd5\u5728\u8ba1\u7b97\u673a\u4e0a\u7684\u7cbe\u5999\u6f14\u7ece\u3002

    \u4e8b\u5b9e\u4e0a\uff0c\u5728\u8ba1\u7b97\u673a\u95ee\u4e16\u4e4b\u524d\uff0c\u7b97\u6cd5\u548c\u6570\u636e\u7ed3\u6784\u5c31\u5df2\u7ecf\u5b58\u5728\u4e8e\u4e16\u754c\u7684\u5404\u4e2a\u89d2\u843d\u3002\u65e9\u671f\u7684\u7b97\u6cd5\u76f8\u5bf9\u7b80\u5355\uff0c\u4f8b\u5982\u53e4\u4ee3\u7684\u8ba1\u6570\u65b9\u6cd5\u548c\u5de5\u5177\u5236\u4f5c\u6b65\u9aa4\u7b49\u3002\u968f\u7740\u6587\u660e\u7684\u8fdb\u6b65\uff0c\u7b97\u6cd5\u9010\u6e10\u53d8\u5f97\u66f4\u52a0\u7cbe\u7ec6\u548c\u590d\u6742\u3002\u4ece\u5de7\u593a\u5929\u5de5\u7684\u5320\u4eba\u6280\u827a\u3001\u5230\u89e3\u653e\u751f\u4ea7\u529b\u7684\u5de5\u4e1a\u4ea7\u54c1\u3001\u518d\u5230\u5b87\u5b99\u8fd0\u884c\u7684\u79d1\u5b66\u89c4\u5f8b\uff0c\u51e0\u4e4e\u6bcf\u4e00\u4ef6\u5e73\u51e1\u6216\u4ee4\u4eba\u60ca\u53f9\u7684\u4e8b\u7269\u80cc\u540e\uff0c\u90fd\u9690\u85cf\u7740\u7cbe\u5999\u7684\u7b97\u6cd5\u601d\u60f3\u3002

    \u540c\u6837\uff0c\u6570\u636e\u7ed3\u6784\u65e0\u5904\u4e0d\u5728\uff1a\u5927\u5230\u793e\u4f1a\u7f51\u7edc\uff0c\u5c0f\u5230\u5730\u94c1\u7ebf\u8def\uff0c\u8bb8\u591a\u7cfb\u7edf\u90fd\u53ef\u4ee5\u5efa\u6a21\u4e3a\u201c\u56fe\u201d\uff1b\u5927\u5230\u4e00\u4e2a\u56fd\u5bb6\uff0c\u5c0f\u5230\u4e00\u4e2a\u5bb6\u5ead\uff0c\u793e\u4f1a\u7684\u4e3b\u8981\u7ec4\u7ec7\u5f62\u5f0f\u5448\u73b0\u51fa\u201c\u6811\u201d\u7684\u7279\u5f81\uff1b\u51ac\u5929\u7684\u8863\u670d\u5c31\u50cf\u201c\u6808\u201d\uff0c\u6700\u5148\u7a7f\u4e0a\u7684\u6700\u540e\u624d\u80fd\u8131\u4e0b\uff1b\u7fbd\u6bdb\u7403\u7b52\u5219\u5982\u540c\u201c\u961f\u5217\u201d\uff0c\u4e00\u7aef\u653e\u5165\u3001\u53e6\u4e00\u7aef\u53d6\u51fa\uff1b\u5b57\u5178\u5c31\u50cf\u4e00\u4e2a\u201c\u54c8\u5e0c\u8868\u201d\uff0c\u80fd\u591f\u5feb\u901f\u67e5\u627e\u76ee\u6807\u8bcd\u6761\u3002

    \u90a3\u4e48\uff0c\u4ec0\u4e48\u662f\u7b97\u6cd5\uff0c\u5b83\u5728\u6211\u4eec\u65e5\u5e38\u751f\u6d3b\u4e2d\u626e\u6f14\u7740\u600e\u6837\u7684\u89d2\u8272\uff1f\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u5c31\u8fd9\u4e9b\u95ee\u9898\u5c55\u5f00\u63a2\u8ba8\u3002

    "},{"location":"chapter_introduction/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 1.1 \u00a0 \u7b97\u6cd5\u65e0\u5904\u4e0d\u5728
    • 1.2 \u00a0 \u7b97\u6cd5\u662f\u4ec0\u4e48
    • 1.3 \u00a0 \u5c0f\u7ed3
    "},{"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\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\u6211\u5c06\u4e3e\u51e0\u4e2a\u5177\u4f53\u7684\u4f8b\u5b50\u6765\u8bc1\u5b9e\u8fd9\u4e00\u70b9\u3002

    \u4f8b\u4e00\uff1a\u67e5\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\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\u6309\u7167\u56fe 1-1 \u6240\u793a\u7684\u65b9\u5f0f\u5b9e\u73b0\u3002

    1. \u7ffb\u5f00\u5b57\u5178\u7ea6\u4e00\u534a\u7684\u9875\u6570\uff0c\u67e5\u770b\u8be5\u9875\u7684\u9996\u5b57\u6bcd\u662f\u4ec0\u4e48\uff0c\u5047\u8bbe\u9996\u5b57\u6bcd\u4e3a \\(m\\) \u3002
    2. \u7531\u4e8e\u5728\u62fc\u97f3\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\u3002
    3. \u4e0d\u65ad\u91cd\u590d\u6b65\u9aa4 1. \u548c \u6b65\u9aa4 2. \uff0c\u76f4\u81f3\u627e\u5230\u62fc\u97f3\u9996\u5b57\u6bcd\u4e3a \\(r\\) \u7684\u9875\u7801\u4e3a\u6b62\u3002
    <1><2><3><4><5>

    \u56fe 1-1 \u00a0 \u67e5\u5b57\u5178\u6b65\u9aa4

    \u67e5\u5b57\u5178\u8fd9\u4e2a\u5c0f\u5b66\u751f\u5fc5\u5907\u6280\u80fd\uff0c\u5b9e\u9645\u4e0a\u5c31\u662f\u8457\u540d\u7684\u201c\u4e8c\u5206\u67e5\u627e\u201d\u7b97\u6cd5\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\u201c\u6570\u7ec4\u201d\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\u201c\u4e8c\u5206\u67e5\u627e\u201d\u3002

    \u4f8b\u4e8c\uff1a\u6574\u7406\u6251\u514b\u3002\u6211\u4eec\u5728\u6253\u724c\u65f6\uff0c\u6bcf\u5c40\u90fd\u9700\u8981\u6574\u7406\u624b\u4e2d\u7684\u6251\u514b\u724c\uff0c\u4f7f\u5176\u4ece\u5c0f\u5230\u5927\u6392\u5217\uff0c\u5b9e\u73b0\u6d41\u7a0b\u5982\u56fe 1-2 \u6240\u793a\u3002

    1. \u5c06\u6251\u514b\u724c\u5212\u5206\u4e3a\u201c\u6709\u5e8f\u201d\u548c\u201c\u65e0\u5e8f\u201d\u4e24\u90e8\u5206\uff0c\u5e76\u5047\u8bbe\u521d\u59cb\u72b6\u6001\u4e0b\u6700\u5de6 1 \u5f20\u6251\u514b\u724c\u5df2\u7ecf\u6709\u5e8f\u3002
    2. \u5728\u65e0\u5e8f\u90e8\u5206\u62bd\u51fa\u4e00\u5f20\u6251\u514b\u724c\uff0c\u63d2\u5165\u81f3\u6709\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\uff1b\u5b8c\u6210\u540e\u6700\u5de6 2 \u5f20\u6251\u514b\u5df2\u7ecf\u6709\u5e8f\u3002
    3. \u4e0d\u65ad\u5faa\u73af\u6b65\u9aa4 2. \uff0c\u6bcf\u4e00\u8f6e\u5c06\u4e00\u5f20\u6251\u514b\u724c\u4ece\u65e0\u5e8f\u90e8\u5206\u63d2\u5165\u81f3\u6709\u5e8f\u90e8\u5206\uff0c\u76f4\u81f3\u6240\u6709\u6251\u514b\u724c\u90fd\u6709\u5e8f\u3002

    \u56fe 1-2 \u00a0 \u6251\u514b\u6392\u5e8f\u6b65\u9aa4

    \u4e0a\u8ff0\u6574\u7406\u6251\u514b\u724c\u7684\u65b9\u6cd5\u672c\u8d28\u4e0a\u662f\u201c\u63d2\u5165\u6392\u5e8f\u201d\u7b97\u6cd5\uff0c\u5b83\u5728\u5904\u7406\u5c0f\u578b\u6570\u636e\u96c6\u65f6\u975e\u5e38\u9ad8\u6548\u3002\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\u7684\u6392\u5e8f\u5e93\u51fd\u6570\u4e2d\u90fd\u6709\u63d2\u5165\u6392\u5e8f\u7684\u8eab\u5f71\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\u4e86\u6536\u94f6\u5458 \\(100\\) \u5143\uff0c\u5219\u6536\u94f6\u5458\u9700\u8981\u627e\u6211\u4eec \\(31\\) \u5143\u3002\u4ed6\u4f1a\u5f88\u81ea\u7136\u5730\u5b8c\u6210\u5982\u56fe 1-3 \u6240\u793a\u7684\u601d\u8003\u3002

    1. \u53ef\u9009\u9879\u662f\u6bd4 \\(31\\) \u5143\u9762\u503c\u66f4\u5c0f\u7684\u8d27\u5e01\uff0c\u5305\u62ec \\(1\\) \u5143\u3001\\(5\\) \u5143\u3001\\(10\\) \u5143\u3001\\(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

    \u56fe 1-3 \u00a0 \u8d27\u5e01\u627e\u96f6\u8fc7\u7a0b

    \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\u201c\u8d2a\u5fc3\u201d\u7b97\u6cd5\u3002

    \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\u5f97\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

    \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\u8bf7\u7ee7\u7eed\u5f80\u4e0b\u9605\u8bfb\uff0c\u672c\u4e66\u5c06\u5f15\u5bfc\u4f60\u8fc8\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\u5b57\u5178\u7684\u539f\u7406\u4e0e\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u76f8\u4e00\u81f4\u3002\u4e8c\u5206\u67e5\u627e\u7b97\u6cd5\u4f53\u73b0\u4e86\u5206\u800c\u6cbb\u4e4b\u7684\u91cd\u8981\u7b97\u6cd5\u601d\u60f3\u3002
    • \u6574\u7406\u6251\u514b\u7684\u8fc7\u7a0b\u4e0e\u63d2\u5165\u6392\u5e8f\u7b97\u6cd5\u975e\u5e38\u7c7b\u4f3c\u3002\u63d2\u5165\u6392\u5e8f\u7b97\u6cd5\u9002\u5408\u6392\u5e8f\u5c0f\u578b\u6570\u636e\u96c6\u3002
    • \u8d27\u5e01\u627e\u96f6\u7684\u6b65\u9aa4\u672c\u8d28\u4e0a\u662f\u8d2a\u5fc3\u7b97\u6cd5\uff0c\u6bcf\u4e00\u6b65\u90fd\u91c7\u53d6\u5f53\u524d\u770b\u6765\u6700\u597d\u7684\u9009\u62e9\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\u662f\u6570\u636e\u7ed3\u6784\u53d1\u6325\u4f5c\u7528\u7684\u821e\u53f0\u3002
    • \u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7c7b\u6bd4\u4e3a\u62fc\u88c5\u79ef\u6728\uff0c\u79ef\u6728\u4ee3\u8868\u6570\u636e\uff0c\u79ef\u6728\u7684\u5f62\u72b6\u548c\u8fde\u63a5\u65b9\u5f0f\u7b49\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\uff0c\u5b83\u5177\u6709\u4ee5\u4e0b\u7279\u6027\u3002

    • \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\u5728\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\uff0c\u5177\u6709\u4ee5\u4e0b\u8bbe\u8ba1\u76ee\u6807\u3002

    • \u7a7a\u95f4\u5360\u7528\u5c3d\u91cf\u5c11\uff0c\u4ee5\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\u7b97\u6cd5\u9ad8\u6548\u8fd0\u884c\u3002

    \u6570\u636e\u7ed3\u6784\u8bbe\u8ba1\u662f\u4e00\u4e2a\u5145\u6ee1\u6743\u8861\u7684\u8fc7\u7a0b\u3002\u5982\u679c\u60f3\u5728\u67d0\u65b9\u9762\u53d6\u5f97\u63d0\u5347\uff0c\u5f80\u5f80\u9700\u8981\u5728\u53e6\u4e00\u65b9\u9762\u4f5c\u51fa\u59a5\u534f\u3002\u4e0b\u9762\u4e3e\u4e24\u4e2a\u4f8b\u5b50\u3002

    • \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\u3002
    • \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":"

    \u5982\u56fe 1-4 \u6240\u793a\uff0c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u9ad8\u5ea6\u76f8\u5173\u3001\u7d27\u5bc6\u7ed3\u5408\uff0c\u5177\u4f53\u8868\u73b0\u5728\u4ee5\u4e0b\u4e09\u4e2a\u65b9\u9762\u3002

    • \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\u64cd\u4f5c\u6570\u636e\u7684\u65b9\u6cd5\u3002
    • \u7b97\u6cd5\u662f\u6570\u636e\u7ed3\u6784\u53d1\u6325\u4f5c\u7528\u7684\u821e\u53f0\u3002\u6570\u636e\u7ed3\u6784\u672c\u8eab\u4ec5\u5b58\u50a8\u6570\u636e\u4fe1\u606f\uff0c\u7ed3\u5408\u7b97\u6cd5\u624d\u80fd\u89e3\u51b3\u7279\u5b9a\u95ee\u9898\u3002
    • \u7b97\u6cd5\u901a\u5e38\u53ef\u4ee5\u57fa\u4e8e\u4e0d\u540c\u7684\u6570\u636e\u7ed3\u6784\u5b9e\u73b0\uff0c\u4f46\u6267\u884c\u6548\u7387\u53ef\u80fd\u76f8\u5dee\u5f88\u5927\uff0c\u9009\u62e9\u5408\u9002\u7684\u6570\u636e\u7ed3\u6784\u662f\u5173\u952e\u3002

    \u56fe 1-4 \u00a0 \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u5173\u7cfb

    \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u72b9\u5982\u56fe 1-5 \u6240\u793a\u7684\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

    \u56fe 1-5 \u00a0 \u62fc\u88c5\u79ef\u6728

    \u4e24\u8005\u7684\u8be6\u7ec6\u5bf9\u5e94\u5173\u7cfb\u5982\u8868 1-1 \u6240\u793a\u3002

    \u8868 1-1 \u00a0 \u5c06\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7c7b\u6bd4\u4e3a\u62fc\u88c5\u79ef\u6728

    \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5 \u62fc\u88c5\u79ef\u6728 \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\u8bf4\u660e\u7684\u662f\uff0c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u662f\u72ec\u7acb\u4e8e\u7f16\u7a0b\u8bed\u8a00\u7684\u3002\u6b63\u56e0\u5982\u6b64\uff0c\u672c\u4e66\u5f97\u4ee5\u63d0\u4f9b\u57fa\u4e8e\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\u201c\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u201d\u7b80\u79f0\u4e3a\u201c\u7b97\u6cd5\u201d\u3002\u6bd4\u5982\u4f17\u6240\u5468\u77e5\u7684 LeetCode \u7b97\u6cd5\u9898\u76ee\uff0c\u5b9e\u9645\u4e0a\u540c\u65f6\u8003\u67e5\u6570\u636e\u7ed3\u6784\u548c\u7b97\u6cd5\u4e24\u65b9\u9762\u7684\u77e5\u8bc6\u3002

    "},{"location":"chapter_paperbook/","title":"\u7eb8\u8d28\u4e66","text":"

    \u7ecf\u8fc7\u957f\u65f6\u95f4\u7684\u6253\u78e8\uff0c\u300aHello \u7b97\u6cd5\u300b\u7eb8\u8d28\u4e66\u7ec8\u4e8e\u53d1\u5e03\u4e86\uff01\u6b64\u65f6\u7684\u5fc3\u60c5\u53ef\u4ee5\u7528\u4e00\u53e5\u8bd7\u6765\u5f62\u5bb9\uff1a

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

    \u4ee5\u4e0b\u89c6\u9891\u5c55\u793a\u4e86\u7eb8\u8d28\u4e66\uff0c\u5e76\u4e14\u5305\u542b\u6211\u7684\u4e00\u4e9b\u601d\u8003\uff1a

    • \u5b66\u4e60\u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u7684\u91cd\u8981\u6027\u3002
    • \u4e3a\u4ec0\u4e48\u5728\u7eb8\u8d28\u4e66\u4e2d\u9009\u62e9 Python\u3002
    • \u5bf9\u77e5\u8bc6\u5206\u4eab\u7684\u7406\u89e3\u3002

    \u65b0\u4eba UP \u4e3b\uff0c\u8bf7\u591a\u591a\u5173\u7167\u3001\u4e00\u952e\u4e09\u8fde\uff5e\u8c22\u8c22\uff01

    \u9644\u7eb8\u8d28\u4e66\u5feb\u7167\uff1a

    "},{"location":"chapter_paperbook/#_2","title":"\u4f18\u52bf\u4e0e\u4e0d\u8db3","text":"

    \u603b\u7ed3\u4e00\u4e0b\u7eb8\u8d28\u4e66\u53ef\u80fd\u4f1a\u7ed9\u5927\u5bb6\u5e26\u6765\u60ca\u559c\u7684\u5730\u65b9\uff1a

    • \u91c7\u7528\u5168\u5f69\u5370\u5237\uff0c\u80fd\u591f\u539f\u6c41\u539f\u5473\u5730\u53d1\u6325\u51fa\u672c\u4e66\u201c\u52a8\u753b\u56fe\u89e3\u201d\u7684\u4f18\u52bf\u3002
    • \u8003\u7a76\u7eb8\u5f20\u6750\u8d28\uff0c\u65e2\u4fdd\u8bc1\u8272\u5f69\u9ad8\u5ea6\u8fd8\u539f\uff0c\u4e5f\u4fdd\u7559\u7eb8\u8d28\u4e66\u7279\u6709\u7684\u8d28\u611f\u3002
    • \u5728\u4e0d\u63d0\u5347\u5b9a\u4ef7\u7684\u524d\u63d0\u4e0b\uff0c\u9644\u8d60\u601d\u7ef4\u5bfc\u56fe\u6298\u9875\u3001\u4e66\u7b7e\u3002
    • \u7eb8\u8d28\u4e66\u3001\u7f51\u9875\u7248\u3001PDF \u7248\u5185\u5bb9\u540c\u6b65\uff0c\u968f\u610f\u5207\u6362\u9605\u8bfb\u3002

    Tip

    \u7531\u4e8e\u7eb8\u8d28\u4e66\u548c\u7f51\u9875\u7248\u7684\u540c\u6b65\u6210\u672c\u8f83\u5927\uff0c\u56e0\u6b64\u53ef\u80fd\u4f1a\u6709\u4e00\u4e9b\u7ec6\u8282\u4e0a\u7684\u4e0d\u540c\uff0c\u8bf7\u60a8\u89c1\u8c05\uff01

    \u5f53\u7136\uff0c\u7eb8\u8d28\u4e66\u4e5f\u6709\u4e00\u4e9b\u503c\u5f97\u5927\u5bb6\u5165\u624b\u524d\u8003\u8651\u7684\u5730\u65b9\uff1a

    • \u4f7f\u7528 Python \u8bed\u8a00\uff0c\u53ef\u80fd\u4e0d\u5339\u914d\u4f60\u7684\u4e3b\u8bed\u8a00\uff08\u4e5f\u8bb8\u53ef\u4ee5\u8d81\u6b64\u673a\u4f1a\u7ec3\u4e60 Python\uff09\u3002
    • \u5168\u5f69\u5370\u5237\u867d\u7136\u5927\u5e45\u63d0\u5347\u4e86\u9605\u8bfb\u4f53\u9a8c\uff0c\u4f46\u4ef7\u683c\u4f1a\u6bd4\u9ed1\u767d\u5370\u5237\u9ad8\u4e00\u4e9b\u3002

    Tip

    \u201c\u5370\u5237\u8d28\u91cf\u201d\u548c\u201c\u4ef7\u683c\u201d\u5c31\u50cf\u7b97\u6cd5\u4e2d\u7684\u201c\u65f6\u95f4\u6548\u7387\u201d\u548c\u201c\u7a7a\u95f4\u6548\u7387\u201d\uff0c\u96be\u4ee5\u4e24\u5168\u3002\u800c\u6211\u8ba4\u4e3a\uff0c\u201c\u5370\u5237\u8d28\u91cf\u201d\u5bf9\u5e94\u7684\u662f\u201c\u65f6\u95f4\u6548\u7387\u201d\uff0c\u66f4\u5e94\u8be5\u88ab\u6ce8\u91cd\u3002

    "},{"location":"chapter_paperbook/#_3","title":"\u8d2d\u4e70\u94fe\u63a5","text":"

    \u5982\u679c\u4f60\u5bf9\u7eb8\u8d28\u4e66\u611f\u5174\u8da3\uff0c\u53ef\u4ee5\u8003\u8651\u5165\u624b\u4e00\u672c\u3002\u6211\u4eec\u4e3a\u5927\u5bb6\u4e89\u53d6\u5230\u4e86\u65b0\u4e66 5 \u6298\u4f18\u60e0\uff0c\u8bf7\u89c1\u6b64\u94fe\u63a5\u6216\u626b\u63cf\u4ee5\u4e0b\u4e8c\u7ef4\u7801\uff1a

    "},{"location":"chapter_paperbook/#_4","title":"\u5c3e\u8bb0","text":"

    \u8d77\u521d\uff0c\u6211\u4f4e\u4f30\u4e86\u7eb8\u8d28\u4e66\u51fa\u7248\u7684\u5de5\u4f5c\u91cf\uff0c\u4ee5\u4e3a\u53ea\u8981\u7ef4\u62a4\u597d\u4e86\u5f00\u6e90\u9879\u76ee\uff0c\u7eb8\u8d28\u7248\u5c31\u53ef\u4ee5\u901a\u8fc7\u67d0\u4e9b\u81ea\u52a8\u5316\u624b\u6bb5\u751f\u6210\u51fa\u6765\u3002\u5b9e\u8df5\u8bc1\u660e\uff0c\u7eb8\u8d28\u4e66\u7684\u751f\u4ea7\u6d41\u7a0b\u4e0e\u5f00\u6e90\u9879\u76ee\u7684\u66f4\u65b0\u673a\u5236\u5b58\u5728\u5f88\u5927\u7684\u4e0d\u540c\uff0c\u4e24\u8005\u4e4b\u95f4\u7684\u8f6c\u5316\u9700\u8981\u505a\u8bb8\u591a\u989d\u5916\u5de5\u4f5c\u3002

    \u4e00\u672c\u4e66\u7684\u521d\u7a3f\u4e0e\u8fbe\u5230\u51fa\u7248\u6807\u51c6\u7684\u5b9a\u7a3f\u4e4b\u95f4\u4ecd\u6709\u8f83\u957f\u8ddd\u79bb\uff0c\u9700\u8981\u51fa\u7248\u793e\uff08\u7b56\u5212\u3001\u7f16\u8f91\u3001\u8bbe\u8ba1\u3001\u5e02\u573a\u7b49\uff09\u4e0e\u4f5c\u8005\u7684\u901a\u529b\u5408\u4f5c\u3001\u957f\u671f\u96d5\u7422\u3002\u5728\u6b64\u611f\u8c22\u56fe\u7075\u7b56\u5212\u7f16\u8f91\u738b\u519b\u82b1\u3001\u4ee5\u53ca\u4eba\u6c11\u90ae\u7535\u51fa\u7248\u793e\u548c\u56fe\u7075\u793e\u533a\u6bcf\u4f4d\u53c2\u4e0e\u672c\u4e66\u51fa\u7248\u6d41\u7a0b\u7684\u5de5\u4f5c\u4eba\u5458\uff01

    \u5e0c\u671b\u8fd9\u672c\u4e66\u80fd\u591f\u5e2e\u52a9\u5230\u4f60\uff01

    "},{"location":"chapter_preface/","title":"\u7b2c 0 \u7ae0 \u00a0 \u524d\u8a00","text":"

    Abstract

    \u7b97\u6cd5\u72b9\u5982\u7f8e\u5999\u7684\u4ea4\u54cd\u4e50\uff0c\u6bcf\u4e00\u884c\u4ee3\u7801\u90fd\u50cf\u97f5\u5f8b\u822c\u6d41\u6dcc\u3002

    \u613f\u8fd9\u672c\u4e66\u5728\u4f60\u7684\u8111\u6d77\u4e2d\u8f7b\u8f7b\u54cd\u8d77\uff0c\u7559\u4e0b\u72ec\u7279\u800c\u6df1\u523b\u7684\u65cb\u5f8b\u3002

    \u4e24\u5e74\u524d\uff0c\u6211\u5728\u529b\u6263\u4e0a\u5206\u4eab\u4e86\u201c\u5251\u6307 Offer\u201d\u7cfb\u5217\u9898\u89e3\uff0c\u53d7\u5230\u4e86\u8bb8\u591a\u8bfb\u8005\u7684\u9f13\u52b1\u548c\u652f\u6301\u3002\u5728\u4e0e\u8bfb\u8005\u4ea4\u6d41\u671f\u95f4\uff0c\u6211\u6700\u5e38\u88ab\u95ee\u7684\u4e00\u4e2a\u95ee\u9898\u662f\u201c\u5982\u4f55\u5165\u95e8\u7b97\u6cd5\u201d\u3002\u9010\u6e10\u5730\uff0c\u6211\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\u3001\u76f4\u63a5\u4e14\u6709\u6548\u3002\u7136\u800c\u5237\u9898\u5c31\u5982\u540c\u73a9\u201c\u626b\u96f7\u201d\u6e38\u620f\uff0c\u81ea\u5b66\u80fd\u529b\u5f3a\u7684\u4eba\u80fd\u591f\u987a\u5229\u5c06\u5730\u96f7\u9010\u4e2a\u6392\u6389\uff0c\u800c\u57fa\u7840\u4e0d\u8db3\u7684\u4eba\u5f88\u53ef\u80fd\u88ab\u70b8\u5f97\u6ee1\u5934\u662f\u5305\uff0c\u5e76\u5728\u632b\u6298\u4e2d\u6b65\u6b65\u9000\u7f29\u3002\u901a\u8bfb\u6559\u6750\u4e5f\u662f\u4e00\u79cd\u5e38\u89c1\u505a\u6cd5\uff0c\u4f46\u5bf9\u4e8e\u9762\u5411\u6c42\u804c\u7684\u4eba\u6765\u8bf4\uff0c\u6bd5\u4e1a\u8bba\u6587\u3001\u6295\u9012\u7b80\u5386\u3001\u51c6\u5907\u7b14\u8bd5\u548c\u9762\u8bd5\u5df2\u7ecf\u6d88\u8017\u4e86\u5927\u90e8\u5206\u7cbe\u529b\uff0c\u5543\u539a\u91cd\u7684\u4e66\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\u201c\u627e\u201d\u5230\u4e86\u4f60\u3002\u672c\u4e66\u662f\u6211\u5bf9\u8fd9\u4e2a\u95ee\u9898\u7ed9\u51fa\u7684\u7b54\u6848\uff0c\u5373\u4f7f\u4e0d\u662f\u6700\u4f18\u89e3\uff0c\u4e5f\u81f3\u5c11\u662f\u4e00\u6b21\u79ef\u6781\u7684\u5c1d\u8bd5\u3002\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\u3001\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\u5237\u9898\u548c\u9605\u8bfb\u6587\u732e\uff0c\u9010\u6b65\u6784\u5efa\u8d77\u5b8c\u6574\u7684\u77e5\u8bc6\u4f53\u7cfb\u3002

    \u6211\u6df1\u6df1\u8d5e\u540c\u8d39\u66fc\u6559\u6388\u6240\u8a00\uff1a\u201cKnowledge isn't free. You have to pay attention.\u201d\u4ece\u8fd9\u4e2a\u610f\u4e49\u4e0a\u770b\uff0c\u8fd9\u672c\u4e66\u5e76\u975e\u5b8c\u5168\u201c\u514d\u8d39\u201d\u3002\u4e3a\u4e86\u4e0d\u8f9c\u8d1f\u4f60\u4e3a\u672c\u4e66\u6240\u4ed8\u51fa\u7684\u5b9d\u8d35\u201c\u6ce8\u610f\u529b\u201d\uff0c\u6211\u4f1a\u7aed\u5c3d\u6240\u80fd\uff0c\u6295\u5165\u6700\u5927\u7684\u201c\u6ce8\u610f\u529b\u201d\u6765\u5b8c\u6210\u672c\u4e66\u7684\u521b\u4f5c\u3002

    "},{"location":"chapter_preface/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 0.1 \u00a0 \u5173\u4e8e\u672c\u4e66
    • 0.2 \u00a0 \u5982\u4f55\u4f7f\u7528\u672c\u4e66
    • 0.3 \u00a0 \u5c0f\u7ed3
    "},{"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\u3001\u514d\u8d39\u3001\u5bf9\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\uff0c\u5b66\u4e60\u66f2\u7ebf\u5e73\u6ed1\u3002
    • \u7b97\u6cd5\u6e90\u4ee3\u7801\u7686\u53ef\u4e00\u952e\u8fd0\u884c\uff0c\u652f\u6301 Python\u3001C++\u3001Java\u3001C#\u3001Go\u3001Swift\u3001JavaScript\u3001TypeScript\u3001Dart\u3001Rust\u3001C \u548c Zig \u7b49\u8bed\u8a00\u3002
    • \u9f13\u52b1\u8bfb\u8005\u5728\u7ebf\u4e0a\u7ae0\u8282\u8bc4\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\u3002
    "},{"location":"chapter_preface/about_the_book/#011","title":"0.1.1 \u00a0 \u8bfb\u8005\u5bf9\u8c61","text":"

    \u82e5\u4f60\u662f\u7b97\u6cd5\u521d\u5b66\u8005\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\u672c\u4e66\u6b63\u662f\u4e3a\u4f60\u91cf\u8eab\u5b9a\u5236\u7684\uff01

    \u5982\u679c\u4f60\u5df2\u7ecf\u79ef\u7d2f\u4e00\u5b9a\u7684\u5237\u9898\u91cf\uff0c\u719f\u6089\u5927\u90e8\u5206\u9898\u578b\uff0c\u90a3\u4e48\u672c\u4e66\u53ef\u52a9\u4f60\u56de\u987e\u4e0e\u68b3\u7406\u7b97\u6cd5\u77e5\u8bc6\u4f53\u7cfb\uff0c\u4ed3\u5e93\u6e90\u4ee3\u7801\u53ef\u4ee5\u5f53\u4f5c\u201c\u5237\u9898\u5de5\u5177\u5e93\u201d\u6216\u201c\u7b97\u6cd5\u5b57\u5178\u201d\u6765\u4f7f\u7528\u3002

    \u82e5\u4f60\u662f\u7b97\u6cd5\u201c\u5927\u795e\u201d\uff0c\u6211\u4eec\u671f\u5f85\u6536\u5230\u4f60\u7684\u5b9d\u8d35\u5efa\u8bae\uff0c\u6216\u8005\u4e00\u8d77\u53c2\u4e0e\u521b\u4f5c\u3002

    \u524d\u7f6e\u6761\u4ef6

    \u4f60\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\u7684\u4e3b\u8981\u5185\u5bb9\u5982\u56fe 0-1 \u6240\u793a\u3002

    • \u590d\u6742\u5ea6\u5206\u6790\uff1a\u6570\u636e\u7ed3\u6784\u548c\u7b97\u6cd5\u7684\u8bc4\u4ef7\u7ef4\u5ea6\u4e0e\u65b9\u6cd5\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u548c\u7a7a\u95f4\u590d\u6742\u5ea6\u7684\u63a8\u7b97\u65b9\u6cd5\u3001\u5e38\u89c1\u7c7b\u578b\u3001\u793a\u4f8b\u7b49\u3002
    • \u6570\u636e\u7ed3\u6784\uff1a\u57fa\u672c\u6570\u636e\u7c7b\u578b\u548c\u6570\u636e\u7ed3\u6784\u7684\u5206\u7c7b\u65b9\u6cd5\u3002\u6570\u7ec4\u3001\u94fe\u8868\u3001\u6808\u3001\u961f\u5217\u3001\u54c8\u5e0c\u8868\u3001\u6811\u3001\u5806\u3001\u56fe\u7b49\u6570\u636e\u7ed3\u6784\u7684\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\u641c\u7d22\u3001\u6392\u5e8f\u3001\u5206\u6cbb\u3001\u56de\u6eaf\u3001\u52a8\u6001\u89c4\u5212\u3001\u8d2a\u5fc3\u7b49\u7b97\u6cd5\u7684\u5b9a\u4e49\u3001\u4f18\u7f3a\u70b9\u3001\u6548\u7387\u3001\u5e94\u7528\u573a\u666f\u3001\u89e3\u9898\u6b65\u9aa4\u548c\u793a\u4f8b\u95ee\u9898\u7b49\u3002

    \u56fe 0-1 \u00a0 \u672c\u4e66\u4e3b\u8981\u5185\u5bb9

    "},{"location":"chapter_preface/about_the_book/#013","title":"0.1.3 \u00a0 \u81f4\u8c22","text":"

    \u672c\u4e66\u5728\u5f00\u6e90\u793e\u533a\u4f17\u591a\u8d21\u732e\u8005\u7684\u5171\u540c\u52aa\u529b\u4e0b\u4e0d\u65ad\u5b8c\u5584\u3002\u611f\u8c22\u6bcf\u4e00\u4f4d\u6295\u5165\u65f6\u95f4\u4e0e\u7cbe\u529b\u7684\u64b0\u7a3f\u4eba\uff0c\u4ed6\u4eec\u662f\uff08\u6309\u7167 GitHub \u81ea\u52a8\u751f\u6210\u7684\u987a\u5e8f\uff09\uff1akrahets\u3001codingonion\u3001nuomi1\u3001Gonglja\u3001Reanon\u3001justin-tse\u3001danielsss\u3001hpstory\u3001S-N-O-R-L-A-X\u3001night-cruise\u3001msk397\u3001gvenusleo\u3001RiverTwilight\u3001gyt95\u3001zhuoqinyue\u3001Zuoxun\u3001Xia-Sang\u3001mingXta\u3001FangYuan33\u3001GN-Yu\u3001IsChristina\u3001xBLACKICEx\u3001guowei-gong\u3001Cathay-Chen\u3001mgisr\u3001JoseHung\u3001qualifier1024\u3001pengchzn\u3001Guanngxu\u3001longsizhuo\u3001L-Super\u3001what-is-me\u3001yuan0221\u3001lhxsm\u3001Slone123c\u3001WSL0809\u3001longranger2\u3001theNefelibatas\u3001xiongsp\u3001JeffersonHuang\u3001hongyun-robot\u3001K3v123\u3001yuelinxin\u3001a16su\u3001gaofer\u3001malone6\u3001Wonderdch\u3001xjr7670\u3001DullSword\u3001Horbin-Magician\u3001NI-SW\u3001reeswell\u3001XC-Zero\u3001XiaChuerwu\u3001yd-j\u3001iron-irax\u3001huawuque404\u3001MolDuM\u3001Nigh\u3001KorsChen\u3001foursevenlove\u300152coder\u3001bubble9um\u3001youshaoXG\u3001curly210102\u3001gltianwen\u3001fanchenggang\u3001Transmigration-zhou\u3001FloranceYeh\u3001FreddieLi\u3001ShiMaRing\u3001lipusheng\u3001Javesun99\u3001JackYang-hellobobo\u3001shanghai-Jerry\u30010130w\u3001Keynman\u3001psychelzh\u3001logan-qiu\u3001ZnYang2018\u3001MwumLi\u30011ch0\u3001Phoenix0415\u3001qingpeng9802\u3001Richard-Zhang1019\u3001QiLOL\u3001Suremotoo\u3001Turing-1024-Lee\u3001Evilrabbit520\u3001GaochaoZhu\u3001ZJKung\u3001linzeyan\u3001hezhizhen\u3001ZongYangL\u3001beintentional\u3001czruby\u3001coderlef\u3001dshlstarr\u3001szu17dmy\u3001fbigm\u3001gledfish\u3001hts0000\u3001boloboloda\u3001iStig\u3001jiaxianhua\u3001wenjianmin\u3001keshida\u3001kilikilikid\u3001lclc6\u3001lwbaptx\u3001liuxjerry\u3001lucaswangdev\u3001lyl625760\u3001chadyi\u3001noobcodemaker\u3001selear\u3001siqyka\u3001syd168\u30014yDX3906\u3001tao363\u3001wangwang105\u3001weibk\u3001yabo083\u3001yi427\u3001yishangzhang\u3001zhouLion\u3001baagod\u3001ElaBosak233\u3001xb534\u3001luluxia\u3001yanedie\u3001thomasq0\u3001YangXuanyi \u548c th1nk3r-ing \u3002

    \u672c\u4e66\u7684\u4ee3\u7801\u5ba1\u9605\u5de5\u4f5c\u7531 codingonion\u3001Gonglja\u3001gvenusleo\u3001hpstory\u3001justin-tse\u3001krahets\u3001night-cruise\u3001nuomi1 \u548c Reanon \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

    \u5728\u672c\u4e66\u7684\u521b\u4f5c\u8fc7\u7a0b\u4e2d\uff0c\u6211\u5f97\u5230\u4e86\u8bb8\u591a\u4eba\u7684\u5e2e\u52a9\u3002

    • \u611f\u8c22\u6211\u5728\u516c\u53f8\u7684\u5bfc\u5e08\u674e\u6c50\u535a\u58eb\uff0c\u5728\u4e00\u6b21\u7545\u8c08\u4e2d\u4f60\u9f13\u52b1\u6211\u201c\u5feb\u884c\u52a8\u8d77\u6765\u201d\uff0c\u575a\u5b9a\u4e86\u6211\u5199\u8fd9\u672c\u4e66\u7684\u51b3\u5fc3\uff1b
    • \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\uff1b
    • \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\u201cHello World!\u201d\u7684\u7f8e\u597d\u56de\u5fc6\uff1b
    • \u611f\u8c22\u6821\u94e8\u5728\u77e5\u8bc6\u4ea7\u6743\u65b9\u9762\u63d0\u4f9b\u7684\u4e13\u4e1a\u5e2e\u52a9\uff0c\u8fd9\u5bf9\u672c\u5f00\u6e90\u4e66\u7684\u5b8c\u5584\u8d77\u5230\u4e86\u91cd\u8981\u4f5c\u7528\uff1b
    • \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\u7684\u9a71\u4f7f\u4e0b\u591a\u6b21\u8010\u5fc3\u4fee\u6539\uff1b
    • \u611f\u8c22 @squidfunk \u63d0\u4f9b\u7684\u6392\u7248\u5efa\u8bae\uff0c\u4ee5\u53ca\u4ed6\u5f00\u53d1\u7684\u5f00\u6e90\u6587\u6863\u4e3b\u9898 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\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\u6211\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\u7684\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\u4ef6\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\u4f60\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\u53ef\u4ee5\u5148\u8df3\u8fc7\u3002
    • \u91cd\u8981\u4e13\u6709\u540d\u8bcd\u53ca\u5176\u82f1\u6587\u7ffb\u8bd1\u4f1a\u7528 \u300c \u300d \u62ec\u53f7\u6807\u6ce8\uff0c\u4f8b\u5982 \u300c\u6570\u7ec4 array\u300d \u3002\u5efa\u8bae\u8bb0\u4f4f\u5b83\u4eec\uff0c\u4ee5\u4fbf\u9605\u8bfb\u6587\u732e\u3002
    • \u4e13\u6709\u540d\u8bcd\u548c\u6709\u7279\u6307\u542b\u4e49\u7684\u8bcd\u53e5\u4f1a\u4f7f\u7528 \u201c\u5f15\u53f7\u201d \u6807\u6ce8\uff0c\u4ee5\u907f\u514d\u6b67\u4e49\u3002
    • \u91cd\u8981\u540d\u8bcd\u3001\u91cd\u70b9\u5185\u5bb9\u548c\u603b\u7ed3\u6027\u8bed\u53e5\u4f1a \u52a0\u7c97 \uff0c\u8fd9\u7c7b\u6587\u5b57\u503c\u5f97\u7279\u522b\u5173\u6ce8\u3002
    • \u5f53\u6d89\u53ca\u7f16\u7a0b\u8bed\u8a00\u4e4b\u95f4\u4e0d\u4e00\u81f4\u7684\u540d\u8bcd\u65f6\uff0c\u672c\u4e66\u5747\u4ee5 Python \u4e3a\u51c6\uff0c\u4f8b\u5982\u4f7f\u7528 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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    \"\"\"\u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49\"\"\"\n\n# \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\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\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\n/**\n * \u591a\u884c\n * \u6ce8\u91ca\n */\n
    \n
    // \u6807\u9898\u6ce8\u91ca\uff0c\u7528\u4e8e\u6807\u6ce8\u51fd\u6570\u3001\u7c7b\u3001\u6d4b\u8bd5\u6837\u4f8b\u7b49\n\n// \u5185\u5bb9\u6ce8\u91ca\uff0c\u7528\u4e8e\u8be6\u89e3\u4ee3\u7801\n\n// \u591a\u884c\n// \u6ce8\u91ca\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\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\u4ee5\u56fe\u89e3\u5f62\u5f0f\u5c55\u793a\uff0c\u800c\u6587\u5b57\u5219\u4f5c\u4e3a\u89e3\u91ca\u4e0e\u8865\u5145\u3002

    \u5982\u679c\u4f60\u5728\u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u53d1\u73b0\u67d0\u6bb5\u5185\u5bb9\u63d0\u4f9b\u4e86\u5982\u56fe 0-2 \u6240\u793a\u7684\u52a8\u753b\u56fe\u89e3\uff0c\u8bf7\u4ee5\u56fe\u4e3a\u4e3b\u3001\u4ee5\u6587\u5b57\u4e3a\u8f85\uff0c\u7efc\u5408\u4e24\u8005\u6765\u7406\u89e3\u5185\u5bb9\u3002

    \u56fe 0-2 \u00a0 \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\u5728 GitHub \u4ed3\u5e93\u3002\u5982\u56fe 0-3 \u6240\u793a\uff0c\u6e90\u4ee3\u7801\u9644\u6709\u6d4b\u8bd5\u6837\u4f8b\uff0c\u53ef\u4e00\u952e\u8fd0\u884c\u3002

    \u5982\u679c\u65f6\u95f4\u5141\u8bb8\uff0c\u5efa\u8bae\u4f60\u53c2\u7167\u4ee3\u7801\u81ea\u884c\u6572\u4e00\u904d\u3002\u5982\u679c\u5b66\u4e60\u65f6\u95f4\u6709\u9650\uff0c\u8bf7\u81f3\u5c11\u901a\u8bfb\u5e76\u8fd0\u884c\u6240\u6709\u4ee3\u7801\u3002

    \u4e0e\u9605\u8bfb\u4ee3\u7801\u76f8\u6bd4\uff0c\u7f16\u5199\u4ee3\u7801\u7684\u8fc7\u7a0b\u5f80\u5f80\u80fd\u5e26\u6765\u66f4\u591a\u6536\u83b7\u3002\u52a8\u624b\u5b66\uff0c\u624d\u662f\u771f\u7684\u5b66\u3002

    \u56fe 0-3 \u00a0 \u8fd0\u884c\u4ee3\u7801\u793a\u4f8b

    \u8fd0\u884c\u4ee3\u7801\u7684\u524d\u7f6e\u5de5\u4f5c\u4e3b\u8981\u5206\u4e3a\u4e09\u6b65\u3002

    \u7b2c\u4e00\u6b65\uff1a\u5b89\u88c5\u672c\u5730\u7f16\u7a0b\u73af\u5883\u3002\u8bf7\u53c2\u7167\u9644\u5f55\u6240\u793a\u7684\u6559\u7a0b\u8fdb\u884c\u5b89\u88c5\uff0c\u5982\u679c\u5df2\u5b89\u88c5\uff0c\u5219\u53ef\u8df3\u8fc7\u6b64\u6b65\u9aa4\u3002

    \u7b2c\u4e8c\u6b65\uff1a\u514b\u9686\u6216\u4e0b\u8f7d\u4ee3\u7801\u4ed3\u5e93\u3002\u524d\u5f80 GitHub \u4ed3\u5e93\u3002\u5982\u679c\u5df2\u7ecf\u5b89\u88c5 Git \uff0c\u53ef\u4ee5\u901a\u8fc7\u4ee5\u4e0b\u547d\u4ee4\u514b\u9686\u672c\u4ed3\u5e93\uff1a

    git clone https://github.com/krahets/hello-algo.git\n

    \u5f53\u7136\uff0c\u4f60\u4e5f\u53ef\u4ee5\u5728\u56fe 0-4 \u6240\u793a\u7684\u4f4d\u7f6e\uff0c\u70b9\u51fb\u201cDownload ZIP\u201d\u6309\u94ae\u76f4\u63a5\u4e0b\u8f7d\u4ee3\u7801\u538b\u7f29\u5305\uff0c\u7136\u540e\u5728\u672c\u5730\u89e3\u538b\u5373\u53ef\u3002

    \u56fe 0-4 \u00a0 \u514b\u9686\u4ed3\u5e93\u4e0e\u4e0b\u8f7d\u4ee3\u7801

    \u7b2c\u4e09\u6b65\uff1a\u8fd0\u884c\u6e90\u4ee3\u7801\u3002\u5982\u56fe 0-5 \u6240\u793a\uff0c\u5bf9\u4e8e\u9876\u90e8\u6807\u6709\u6587\u4ef6\u540d\u79f0\u7684\u4ee3\u7801\u5757\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u4ed3\u5e93\u7684 codes \u6587\u4ef6\u5939\u5185\u627e\u5230\u5bf9\u5e94\u7684\u6e90\u4ee3\u7801\u6587\u4ef6\u3002\u6e90\u4ee3\u7801\u6587\u4ef6\u53ef\u4e00\u952e\u8fd0\u884c\uff0c\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

    \u56fe 0-5 \u00a0 \u4ee3\u7801\u5757\u4e0e\u5bf9\u5e94\u7684\u6e90\u4ee3\u7801\u6587\u4ef6

    \u9664\u4e86\u672c\u5730\u8fd0\u884c\u4ee3\u7801\uff0c\u7f51\u9875\u7248\u8fd8\u652f\u6301 Python \u4ee3\u7801\u7684\u53ef\u89c6\u5316\u8fd0\u884c\uff08\u57fa\u4e8e pythontutor \u5b9e\u73b0\uff09\u3002\u5982\u56fe 0-6 \u6240\u793a\uff0c\u4f60\u53ef\u4ee5\u70b9\u51fb\u4ee3\u7801\u5757\u4e0b\u65b9\u7684\u201c\u53ef\u89c6\u5316\u8fd0\u884c\u201d\u6765\u5c55\u5f00\u89c6\u56fe\uff0c\u89c2\u5bdf\u7b97\u6cd5\u4ee3\u7801\u7684\u6267\u884c\u8fc7\u7a0b\uff1b\u4e5f\u53ef\u4ee5\u70b9\u51fb\u201c\u5168\u5c4f\u89c2\u770b\u201d\uff0c\u4ee5\u83b7\u5f97\u66f4\u597d\u7684\u9605\u89c8\u4f53\u9a8c\u3002

    \u56fe 0-6 \u00a0 Python \u4ee3\u7801\u7684\u53ef\u89c6\u5316\u8fd0\u884c

    "},{"location":"chapter_preface/suggestions/#024","title":"0.2.4 \u00a0 \u5728\u63d0\u95ee\u8ba8\u8bba\u4e2d\u5171\u540c\u6210\u957f","text":"

    \u5728\u9605\u8bfb\u672c\u4e66\u65f6\uff0c\u8bf7\u4e0d\u8981\u8f7b\u6613\u8df3\u8fc7\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\u5c0f\u4f19\u4f34\u4eec\u5c06\u7aed\u8bda\u4e3a\u4f60\u89e3\u7b54\uff0c\u4e00\u822c\u60c5\u51b5\u4e0b\u53ef\u5728\u4e24\u5929\u5185\u56de\u590d\u3002

    \u5982\u56fe 0-7 \u6240\u793a\uff0c\u7f51\u9875\u7248\u6bcf\u4e2a\u7ae0\u8282\u7684\u5e95\u90e8\u90fd\u914d\u6709\u8bc4\u8bba\u533a\u3002\u5e0c\u671b\u4f60\u80fd\u591a\u5173\u6ce8\u8bc4\u8bba\u533a\u7684\u5185\u5bb9\u3002\u4e00\u65b9\u9762\uff0c\u4f60\u53ef\u4ee5\u4e86\u89e3\u5927\u5bb6\u9047\u5230\u7684\u95ee\u9898\uff0c\u4ece\u800c\u67e5\u6f0f\u8865\u7f3a\uff0c\u6fc0\u53d1\u66f4\u6df1\u5165\u7684\u601d\u8003\u3002\u53e6\u4e00\u65b9\u9762\uff0c\u671f\u5f85\u4f60\u80fd\u6177\u6168\u5730\u56de\u7b54\u5176\u4ed6\u5c0f\u4f19\u4f34\u7684\u95ee\u9898\uff0c\u5206\u4eab\u4f60\u7684\u89c1\u89e3\uff0c\u5e2e\u52a9\u4ed6\u4eba\u8fdb\u6b65\u3002

    \u56fe 0-7 \u00a0 \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\u3002

    1. \u9636\u6bb5\u4e00\uff1a\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\u7684\u5185\u5bb9\u3002
    2. \u9636\u6bb5\u4e8c\uff1a\u5237\u7b97\u6cd5\u9898\u3002\u5efa\u8bae\u4ece\u70ed\u95e8\u9898\u76ee\u5f00\u5237\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\uff5e5 \u8f6e\u7684\u91cd\u590d\u540e\uff0c\u5c31\u80fd\u5c06\u5176\u7262\u8bb0\u5728\u5fc3\u3002\u63a8\u8350\u7684\u9898\u5355\u548c\u5237\u9898\u8ba1\u5212\u8bf7\u89c1\u6b64 GitHub \u4ed3\u5e93\u3002
    3. \u9636\u6bb5\u4e09\uff1a\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

    \u5982\u56fe 0-8 \u6240\u793a\uff0c\u672c\u4e66\u5185\u5bb9\u4e3b\u8981\u6db5\u76d6\u201c\u9636\u6bb5\u4e00\u201d\uff0c\u65e8\u5728\u5e2e\u52a9\u4f60\u66f4\u9ad8\u6548\u5730\u5c55\u5f00\u9636\u6bb5\u4e8c\u548c\u9636\u6bb5\u4e09\u7684\u5b66\u4e60\u3002

    \u56fe 0-8 \u00a0 \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\u4f60\u5df2\u6709\u4e00\u5b9a\u57fa\u7840\uff0c\u672c\u4e66\u80fd\u5e2e\u52a9\u4f60\u7cfb\u7edf\u56de\u987e\u7b97\u6cd5\u77e5\u8bc6\uff0c\u4e66\u4e2d\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\u548c\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\u81f3\u5173\u91cd\u8981\uff0c\u53ef\u4ee5\u5c11\u8d70\u8bb8\u591a\u5f2f\u8def\u3002
    • \u4e66\u4e2d\u7684\u52a8\u753b\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\u4ee3\u7801\u3002
    • \u672c\u4e66\u7f51\u9875\u7248\u7684\u6bcf\u4e2a\u7ae0\u8282\u90fd\u8bbe\u6709\u8bc4\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] Robert Sedgewick, et al. Algorithms (4th Edition).

    [4] \u4e25\u851a\u654f. \u6570\u636e\u7ed3\u6784\uff08C \u8bed\u8a00\u7248\uff09.

    [5] \u9093\u4fca\u8f89. \u6570\u636e\u7ed3\u6784\uff08C++ \u8bed\u8a00\u7248\uff0c\u7b2c\u4e09\u7248\uff09.

    [6] \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.

    [7] \u7a0b\u6770. \u5927\u8bdd\u6570\u636e\u7ed3\u6784.

    [8] \u738b\u4e89. \u6570\u636e\u7ed3\u6784\u4e0e\u7b97\u6cd5\u4e4b\u7f8e.

    [9] Gayle Laakmann McDowell. Cracking the Coding Interview: 189 Programming Questions and Solutions (6th Edition).

    [10] Aston Zhang, et al. Dive into Deep Learning.

    "},{"location":"chapter_searching/","title":"\u7b2c 10 \u7ae0 \u00a0 \u641c\u7d22","text":"

    Abstract

    \u641c\u7d22\u662f\u4e00\u573a\u672a\u77e5\u7684\u5192\u9669\uff0c\u6211\u4eec\u6216\u8bb8\u9700\u8981\u8d70\u904d\u795e\u79d8\u7a7a\u95f4\u7684\u6bcf\u4e2a\u89d2\u843d\uff0c\u53c8\u6216\u8bb8\u53ef\u4ee5\u5feb\u901f\u9501\u5b9a\u76ee\u6807\u3002

    \u5728\u8fd9\u573a\u5bfb\u89c5\u4e4b\u65c5\u4e2d\uff0c\u6bcf\u4e00\u6b21\u63a2\u7d22\u90fd\u53ef\u80fd\u5f97\u5230\u4e00\u4e2a\u672a\u66fe\u6599\u60f3\u7684\u7b54\u6848\u3002

    "},{"location":"chapter_searching/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 10.1 \u00a0 \u4e8c\u5206\u67e5\u627e
    • 10.2 \u00a0 \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9
    • 10.3 \u00a0 \u4e8c\u5206\u67e5\u627e\u8fb9\u754c
    • 10.4 \u00a0 \u54c8\u5e0c\u4f18\u5316\u7b56\u7565
    • 10.5 \u00a0 \u91cd\u8bc6\u641c\u7d22\u7b97\u6cd5
    • 10.6 \u00a0 \u5c0f\u7ed3
    "},{"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\u7b56\u7565\u7684\u9ad8\u6548\u641c\u7d22\u7b97\u6cd5\u3002\u5b83\u5229\u7528\u6570\u636e\u7684\u6709\u5e8f\u6027\uff0c\u6bcf\u8f6e\u7f29\u5c0f\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\u4e14\u4e0d\u91cd\u590d\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\u793a\u4f8b\u5982\u56fe 10-1 \u6240\u793a\u3002

    \u56fe 10-1 \u00a0 \u4e8c\u5206\u67e5\u627e\u793a\u4f8b\u6570\u636e

    \u5982\u56fe 10-2 \u6240\u793a\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\u8bf7\u6ce8\u610f\uff0c\u4e2d\u62ec\u53f7\u8868\u793a\u95ed\u533a\u95f4\uff0c\u5176\u5305\u542b\u8fb9\u754c\u503c\u672c\u8eab\u3002

    \u63a5\u4e0b\u6765\uff0c\u5faa\u73af\u6267\u884c\u4ee5\u4e0b\u4e24\u6b65\u3002

    1. \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 \\(m = \\lfloor {(i + j) / 2} \\rfloor\\) \uff0c\u5176\u4e2d \\(\\lfloor \\: \\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\u4ee5\u4e0b\u4e09\u79cd\u60c5\u51b5\u3002
      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\\) \u3002
      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\\) \u3002
      3. \u5f53 nums[m] = target \u65f6\uff0c\u8bf4\u660e\u627e\u5230 target \uff0c\u56e0\u6b64\u8fd4\u56de\u7d22\u5f15 \\(m\\) \u3002

    \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

    <1><2><3><4><5><6><7>

    \u56fe 10-2 \u00a0 \u4e8c\u5206\u67e5\u627e\u6d41\u7a0b

    \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

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    i, 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\n    while 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\u987b\u8003\u8651\u5927\u6570\u8d8a\u754c\u95ee\u9898\n        m = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target:\n            i = m + 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        elif nums[m] > target:\n            j = m - 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        else:\n            return m  # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n    return -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\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\n    int 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\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    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\n    int 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\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -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\n    int 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\n    while (i <= j) {\n        int m = i + (j - i) / 2;   // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else                       // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\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\n    i, 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\n    for i <= j {\n        m := i + (j-i)/2      // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        } else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        } else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -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\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    // \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\n    while i <= j {\n        let m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        } else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        } else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -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\n    let i = 0,\n        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\n    while (i <= j) {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m \uff0c\u4f7f\u7528 parseInt() \u5411\u4e0b\u53d6\u6574\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] < target)\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target)\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else 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\n    return -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\n    let i = 0,\n        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\n    while (i <= j) {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] < target) {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        } else if (nums[m] > target) {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n        }\n    }\n    return -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -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\n  int 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\n  while (i <= j) {\n    int m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    if (nums[m] < target) {\n      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n      i = m + 1;\n    } else if (nums[m] > target) {\n      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n      j = m - 1;\n    } else {\n      // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n      return m;\n    }\n  }\n  // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n  return -1;\n}\n
    binary_search.rs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfn binary_search(nums: &[i32], target: i32) -> i32 {\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\n    let mut i = 0;\n    let mut j = nums.len() as i32 - 1;\n    // \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i > j \u65f6\u4e3a\u7a7a\uff09\n    while i <= j {\n        let m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m as usize] < target {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        } else if nums[m as usize] > target {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -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\n    int 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\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.kt
    /* \u4e8c\u5206\u67e5\u627e\uff08\u53cc\u95ed\u533a\u95f4\uff09 */\nfun binarySearch(nums: IntArray, 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\n    var i = 0\n    var 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\n    while (i <= j) {\n        val m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        else  // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1\n}\n
    binary_search.rb
    [class]{}-[func]{binary_search}\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\n    var i: usize = 0;\n    var 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\n    while (i <= j) {\n        var m = i + (j - i) / 2;                // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums.items[m] < target) {           // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1;\n        } else if (nums.items[m] > target) {    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1;\n        } else {                                // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return @intCast(m);\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(\\log n)\\) \uff1a\u5728\u4e8c\u5206\u5faa\u73af\u4e2d\uff0c\u533a\u95f4\u6bcf\u8f6e\u7f29\u5c0f\u4e00\u534a\uff0c\u56e0\u6b64\u5faa\u73af\u6b21\u6570\u4e3a \\(\\log_2 n\\) \u3002

    \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\) \uff1a\u6307\u9488 \\(i\\) \u548c \\(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\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search.py
    def binary_search_lcro(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09\"\"\"\n    # \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    i, 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\n    while i < j:\n        m = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target:\n            i = m + 1  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n        elif nums[m] > target:\n            j = m  # \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n        else:\n            return m  # \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n    return -1  # \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n
    binary_search.cpp
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint binarySearchLCRO(vector<int> &nums, int target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    int 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\n    while (i < j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.java
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint binarySearchLCRO(int[] nums, int target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    int 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\n    while (i < j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.cs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint BinarySearchLCRO(int[] nums, int target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    int 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\n    while (i < j) {\n        int m = i + (j - i) / 2;   // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        else                       // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.go
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfunc binarySearchLCRO(nums []int, target int) int {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    i, 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\n    for i < j {\n        m := i + (j-i)/2      // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1\n        } else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m\n        } else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1\n}\n
    binary_search.swift
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfunc binarySearchLCRO(nums: [Int], target: Int) -> Int {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    var i = nums.startIndex\n    var j = nums.endIndex\n    // \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\n    while i < j {\n        let m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1\n        } else if nums[m] > target { // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m\n        } else { // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1\n}\n
    binary_search.js
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfunction binarySearchLCRO(nums, target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    let i = 0,\n        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\n    while (i < j) {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m \uff0c\u4f7f\u7528 parseInt() \u5411\u4e0b\u53d6\u6574\n        const m = parseInt(i + (j - i) / 2);\n        if (nums[m] < target)\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target)\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n        else return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.ts
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfunction binarySearchLCRO(nums: number[], target: number): number {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    let i = 0,\n        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\n    while (i < j) {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        const m = Math.floor(i + (j - i) / 2);\n        if (nums[m] < target) {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        } else if (nums[m] > target) {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n        }\n    }\n    return -1; // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -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\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n  int 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\n  while (i < j) {\n    int m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    if (nums[m] < target) {\n      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n      i = m + 1;\n    } else if (nums[m] > target) {\n      // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n      j = m;\n    } else {\n      // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n      return m;\n    }\n  }\n  // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n  return -1;\n}\n
    binary_search.rs
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfn binary_search_lcro(nums: &[i32], target: i32) -> i32 {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    let mut i = 0;\n    let mut j = nums.len() as i32;\n    // \u5faa\u73af\uff0c\u5f53\u641c\u7d22\u533a\u95f4\u4e3a\u7a7a\u65f6\u8df3\u51fa\uff08\u5f53 i = j \u65f6\u4e3a\u7a7a\uff09\n    while i < j {\n        let m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m as usize] < target {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        } else if nums[m as usize] > target {\n            // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.c
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nint binarySearchLCRO(int *nums, int len, int target) {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    int 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\n    while (i < j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target)    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        else // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m;\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    binary_search.kt
    /* \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09 */\nfun binarySearchLCRO(nums: IntArray, target: Int): Int {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    var i = 0\n    var 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\n    while (i < j) {\n        val m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1\n        else if (nums[m] > target) // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m\n        else  // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return m\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1\n}\n
    binary_search.rb
    [class]{}-[func]{binary_search_lcro}\n
    binary_search.zig
    // \u4e8c\u5206\u67e5\u627e\uff08\u5de6\u95ed\u53f3\u5f00\u533a\u95f4\uff09\nfn binarySearchLCRO(comptime T: type, nums: std.ArrayList(T), target: T) T {\n    // \u521d\u59cb\u5316\u5de6\u95ed\u53f3\u5f00\u533a\u95f4 [0, n) \uff0c\u5373 i, j \u5206\u522b\u6307\u5411\u6570\u7ec4\u9996\u5143\u7d20\u3001\u5c3e\u5143\u7d20+1\n    var i: usize = 0;\n    var 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\n    while (i <= j) {\n        var m = i + (j - i) / 2;                // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums.items[m] < target) {           // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [m+1, j) \u4e2d\n            i = m + 1;\n        } else if (nums.items[m] > target) {    // \u6b64\u60c5\u51b5\u8bf4\u660e target \u5728\u533a\u95f4 [i, m) \u4e2d\n            j = m;\n        } else {                                // \u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de\u5176\u7d22\u5f15\n            return @intCast(m);\n        }\n    }\n    // \u672a\u627e\u5230\u76ee\u6807\u5143\u7d20\uff0c\u8fd4\u56de -1\n    return -1;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u5982\u56fe 10-3 \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

    \u7531\u4e8e\u201c\u53cc\u95ed\u533a\u95f4\u201d\u8868\u793a\u4e2d\u7684\u5de6\u53f3\u8fb9\u754c\u90fd\u88ab\u5b9a\u4e49\u4e3a\u95ed\u533a\u95f4\uff0c\u56e0\u6b64\u901a\u8fc7\u6307\u9488 \\(i\\) \u548c\u6307\u9488 \\(j\\) \u7f29\u5c0f\u533a\u95f4\u7684\u64cd\u4f5c\u4e5f\u662f\u5bf9\u79f0\u7684\u3002\u8fd9\u6837\u66f4\u4e0d\u5bb9\u6613\u51fa\u9519\uff0c\u56e0\u6b64\u4e00\u822c\u5efa\u8bae\u91c7\u7528\u201c\u53cc\u95ed\u533a\u95f4\u201d\u7684\u5199\u6cd5\u3002

    \u56fe 10-3 \u00a0 \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\u3002

    • \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\u987b\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\u4e3b\u8981\u6709\u4ee5\u4e0b\u539f\u56e0\u3002

    • \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 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.3 \u00a0 \u4e8c\u5206\u67e5\u627e\u8fb9\u754c","text":""},{"location":"chapter_searching/binary_search_edge/#1031","title":"10.3.1 \u00a0 \u67e5\u627e\u5de6\u8fb9\u754c","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6709\u5e8f\u6570\u7ec4 nums \uff0c\u5176\u4e2d\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\u3002\u8bf7\u8fd4\u56de\u6570\u7ec4\u4e2d\u6700\u5de6\u4e00\u4e2a\u5143\u7d20 target \u7684\u7d22\u5f15\u3002\u82e5\u6570\u7ec4\u4e2d\u4e0d\u5305\u542b\u8be5\u5143\u7d20\uff0c\u5219\u8fd4\u56de \\(-1\\) \u3002

    \u56de\u5fc6\u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\u7684\u65b9\u6cd5\uff0c\u641c\u7d22\u5b8c\u6210\u540e \\(i\\) \u6307\u5411\u6700\u5de6\u4e00\u4e2a target \uff0c\u56e0\u6b64\u67e5\u627e\u63d2\u5165\u70b9\u672c\u8d28\u4e0a\u662f\u5728\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target \u7684\u7d22\u5f15\u3002

    \u8003\u8651\u901a\u8fc7\u67e5\u627e\u63d2\u5165\u70b9\u7684\u51fd\u6570\u5b9e\u73b0\u67e5\u627e\u5de6\u8fb9\u754c\u3002\u8bf7\u6ce8\u610f\uff0c\u6570\u7ec4\u4e2d\u53ef\u80fd\u4e0d\u5305\u542b target \uff0c\u8fd9\u79cd\u60c5\u51b5\u53ef\u80fd\u5bfc\u81f4\u4ee5\u4e0b\u4e24\u79cd\u7ed3\u679c\u3002

    • \u63d2\u5165\u70b9\u7684\u7d22\u5f15 \\(i\\) \u8d8a\u754c\u3002
    • \u5143\u7d20 nums[i] \u4e0e target \u4e0d\u76f8\u7b49\u3002

    \u5f53\u9047\u5230\u4ee5\u4e0a\u4e24\u79cd\u60c5\u51b5\u65f6\uff0c\u76f4\u63a5\u8fd4\u56de \\(-1\\) \u5373\u53ef\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_edge.py
    def binary_search_left_edge(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target\"\"\"\n    # \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    i = binary_search_insertion(nums, target)\n    # \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if i == len(nums) or nums[i] != target:\n        return -1\n    # \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i\n
    binary_search_edge.cpp
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint binarySearchLeftEdge(vector<int> &nums, int target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    int i = binarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == nums.size() || nums[i] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.java
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint binarySearchLeftEdge(int[] nums, int target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    int i = binary_search_insertion.binarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == nums.length || nums[i] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.cs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint BinarySearchLeftEdge(int[] nums, int target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == nums.Length || nums[i] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.go
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfunc binarySearchLeftEdge(nums []int, target int) int {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    i := binarySearchInsertion(nums, target)\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if i == len(nums) || nums[i] != target {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i\n}\n
    binary_search_edge.swift
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfunc binarySearchLeftEdge(nums: [Int], target: Int) -> Int {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    let i = binarySearchInsertion(nums: nums, target: target)\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if i == nums.endIndex || nums[i] != target {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i\n}\n
    binary_search_edge.js
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfunction binarySearchLeftEdge(nums, target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    const i = binarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.ts
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfunction binarySearchLeftEdge(nums: Array<number>, target: number): number {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    const i = binarySearchInsertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i === nums.length || nums[i] !== target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.dart
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint binarySearchLeftEdge(List<int> nums, int target) {\n  // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n  int i = binarySearchInsertion(nums, target);\n  // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n  if (i == nums.length || nums[i] != target) {\n    return -1;\n  }\n  // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n  return i;\n}\n
    binary_search_edge.rs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfn binary_search_left_edge(nums: &[i32], target: i32) -> i32 {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    let i = binary_search_insertion(nums, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if i == nums.len() as i32 || nums[i as usize] != target {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    i\n}\n
    binary_search_edge.c
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nint binarySearchLeftEdge(int *nums, int numSize, int target) {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    int i = binarySearchInsertion(nums, numSize, target);\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == numSize || nums[i] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i;\n}\n
    binary_search_edge.kt
    /* \u4e8c\u5206\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target */\nfun binarySearchLeftEdge(nums: IntArray, target: Int): Int {\n    // \u7b49\u4ef7\u4e8e\u67e5\u627e target \u7684\u63d2\u5165\u70b9\n    val i = binarySearchInsertion(nums, target)\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (i == nums.size || nums[i] != target) {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 i\n    return i\n}\n
    binary_search_edge.rb
    [class]{}-[func]{binary_search_left_edge}\n
    binary_search_edge.zig
    [class]{}-[func]{binarySearchLeftEdge}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_searching/binary_search_edge/#1032","title":"10.3.2 \u00a0 \u67e5\u627e\u53f3\u8fb9\u754c","text":"

    \u90a3\u4e48\u5982\u4f55\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target \u5462\uff1f\u6700\u76f4\u63a5\u7684\u65b9\u5f0f\u662f\u4fee\u6539\u4ee3\u7801\uff0c\u66ff\u6362\u5728 nums[m] == target \u60c5\u51b5\u4e0b\u7684\u6307\u9488\u6536\u7f29\u64cd\u4f5c\u3002\u4ee3\u7801\u5728\u6b64\u7701\u7565\uff0c\u6709\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u81ea\u884c\u5b9e\u73b0\u3002

    \u4e0b\u9762\u6211\u4eec\u4ecb\u7ecd\u4e24\u79cd\u66f4\u52a0\u53d6\u5de7\u7684\u65b9\u6cd5\u3002

    "},{"location":"chapter_searching/binary_search_edge/#1","title":"1. \u00a0 \u590d\u7528\u67e5\u627e\u5de6\u8fb9\u754c","text":"

    \u5b9e\u9645\u4e0a\uff0c\u6211\u4eec\u53ef\u4ee5\u5229\u7528\u67e5\u627e\u6700\u5de6\u5143\u7d20\u7684\u51fd\u6570\u6765\u67e5\u627e\u6700\u53f3\u5143\u7d20\uff0c\u5177\u4f53\u65b9\u6cd5\u4e3a\uff1a\u5c06\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\u3002

    \u5982\u56fe 10-7 \u6240\u793a\uff0c\u67e5\u627e\u5b8c\u6210\u540e\uff0c\u6307\u9488 \\(i\\) \u6307\u5411\u6700\u5de6\u4e00\u4e2a target + 1\uff08\u5982\u679c\u5b58\u5728\uff09\uff0c\u800c \\(j\\) \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0c\u56e0\u6b64\u8fd4\u56de \\(j\\) \u5373\u53ef\u3002

    \u56fe 10-7 \u00a0 \u5c06\u67e5\u627e\u53f3\u8fb9\u754c\u8f6c\u5316\u4e3a\u67e5\u627e\u5de6\u8fb9\u754c

    \u8bf7\u6ce8\u610f\uff0c\u8fd4\u56de\u7684\u63d2\u5165\u70b9\u662f \\(i\\) \uff0c\u56e0\u6b64\u9700\u8981\u5c06\u5176\u51cf \\(1\\) \uff0c\u4ece\u800c\u83b7\u5f97 \\(j\\) \uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_edge.py
    def binary_search_right_edge(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target\"\"\"\n    # \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    i = binary_search_insertion(nums, target + 1)\n    # j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    j = i - 1\n    # \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if j == -1 or nums[j] != target:\n        return -1\n    # \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j\n
    binary_search_edge.cpp
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint binarySearchRightEdge(vector<int> &nums, int target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    int i = binarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    int j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.java
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint binarySearchRightEdge(int[] nums, int target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    int j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.cs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint BinarySearchRightEdge(int[] nums, int target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    int j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.go
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfunc binarySearchRightEdge(nums []int, target int) int {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    i := binarySearchInsertion(nums, target+1)\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    j := i - 1\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j\n}\n
    binary_search_edge.swift
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfunc binarySearchRightEdge(nums: [Int], target: Int) -> Int {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    let i = binarySearchInsertion(nums: nums, target: target + 1)\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    let j = i - 1\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if j == -1 || nums[j] != target {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j\n}\n
    binary_search_edge.js
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfunction binarySearchRightEdge(nums, target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    const j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.ts
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfunction binarySearchRightEdge(nums: Array<number>, target: number): number {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    const i = binarySearchInsertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    const j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j === -1 || nums[j] !== target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.dart
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint binarySearchRightEdge(List<int> nums, int target) {\n  // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n  int i = binarySearchInsertion(nums, target + 1);\n  // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n  int j = i - 1;\n  // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n  if (j == -1 || nums[j] != target) {\n    return -1;\n  }\n  // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n  return j;\n}\n
    binary_search_edge.rs
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfn binary_search_right_edge(nums: &[i32], target: i32) -> i32 {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    let i = binary_search_insertion(nums, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    let j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if j == -1 || nums[j as usize] != target {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    j\n}\n
    binary_search_edge.c
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nint binarySearchRightEdge(int *nums, int numSize, int target) {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    int i = binarySearchInsertion(nums, numSize, target + 1);\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    int j = i - 1;\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1;\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j;\n}\n
    binary_search_edge.kt
    /* \u4e8c\u5206\u67e5\u627e\u6700\u53f3\u4e00\u4e2a target */\nfun binarySearchRightEdge(nums: IntArray, target: Int): Int {\n    // \u8f6c\u5316\u4e3a\u67e5\u627e\u6700\u5de6\u4e00\u4e2a target + 1\n    val i = binarySearchInsertion(nums, target + 1)\n    // j \u6307\u5411\u6700\u53f3\u4e00\u4e2a target \uff0ci \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\n    val j = i - 1\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de -1\n    if (j == -1 || nums[j] != target) {\n        return -1\n    }\n    // \u627e\u5230 target \uff0c\u8fd4\u56de\u7d22\u5f15 j\n    return j\n}\n
    binary_search_edge.rb
    [class]{}-[func]{binary_search_right_edge}\n
    binary_search_edge.zig
    [class]{}-[func]{binarySearchRightEdge}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_searching/binary_search_edge/#2","title":"2. \u00a0 \u8f6c\u5316\u4e3a\u67e5\u627e\u5143\u7d20","text":"

    \u6211\u4eec\u77e5\u9053\uff0c\u5f53\u6570\u7ec4\u4e0d\u5305\u542b target \u65f6\uff0c\u6700\u7ec8 \\(i\\) \u548c \\(j\\) \u4f1a\u5206\u522b\u6307\u5411\u9996\u4e2a\u5927\u4e8e\u3001\u5c0f\u4e8e target \u7684\u5143\u7d20\u3002

    \u56e0\u6b64\uff0c\u5982\u56fe 10-8 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u6784\u9020\u4e00\u4e2a\u6570\u7ec4\u4e2d\u4e0d\u5b58\u5728\u7684\u5143\u7d20\uff0c\u7528\u4e8e\u67e5\u627e\u5de6\u53f3\u8fb9\u754c\u3002

    • \u67e5\u627e\u6700\u5de6\u4e00\u4e2a target \uff1a\u53ef\u4ee5\u8f6c\u5316\u4e3a\u67e5\u627e target - 0.5 \uff0c\u5e76\u8fd4\u56de\u6307\u9488 \\(i\\) \u3002
    • \u67e5\u627e\u6700\u53f3\u4e00\u4e2a target \uff1a\u53ef\u4ee5\u8f6c\u5316\u4e3a\u67e5\u627e target + 0.5 \uff0c\u5e76\u8fd4\u56de\u6307\u9488 \\(j\\) \u3002

    \u56fe 10-8 \u00a0 \u5c06\u67e5\u627e\u8fb9\u754c\u8f6c\u5316\u4e3a\u67e5\u627e\u5143\u7d20

    \u4ee3\u7801\u5728\u6b64\u7701\u7565\uff0c\u4ee5\u4e0b\u4e24\u70b9\u503c\u5f97\u6ce8\u610f\u3002

    • \u7ed9\u5b9a\u6570\u7ec4\u4e0d\u5305\u542b\u5c0f\u6570\uff0c\u8fd9\u610f\u5473\u7740\u6211\u4eec\u65e0\u987b\u5173\u5fc3\u5982\u4f55\u5904\u7406\u76f8\u7b49\u7684\u60c5\u51b5\u3002
    • \u56e0\u4e3a\u8be5\u65b9\u6cd5\u5f15\u5165\u4e86\u5c0f\u6570\uff0c\u6240\u4ee5\u9700\u8981\u5c06\u51fd\u6570\u4e2d\u7684\u53d8\u91cf target \u6539\u4e3a\u6d6e\u70b9\u6570\u7c7b\u578b\uff08Python \u65e0\u987b\u6539\u52a8\uff09\u3002
    "},{"location":"chapter_searching/binary_search_insertion/","title":"10.2 \u00a0 \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9","text":"

    \u4e8c\u5206\u67e5\u627e\u4e0d\u4ec5\u53ef\u7528\u4e8e\u641c\u7d22\u76ee\u6807\u5143\u7d20\uff0c\u8fd8\u53ef\u7528\u4e8e\u89e3\u51b3\u8bb8\u591a\u53d8\u79cd\u95ee\u9898\uff0c\u6bd4\u5982\u641c\u7d22\u76ee\u6807\u5143\u7d20\u7684\u63d2\u5165\u4f4d\u7f6e\u3002

    "},{"location":"chapter_searching/binary_search_insertion/#1021","title":"10.2.1 \u00a0 \u65e0\u91cd\u590d\u5143\u7d20\u7684\u60c5\u51b5","text":"

    Question

    \u7ed9\u5b9a\u4e00\u4e2a\u957f\u5ea6\u4e3a \\(n\\) \u7684\u6709\u5e8f\u6570\u7ec4 nums \u548c\u4e00\u4e2a\u5143\u7d20 target \uff0c\u6570\u7ec4\u4e0d\u5b58\u5728\u91cd\u590d\u5143\u7d20\u3002\u73b0\u5c06 target \u63d2\u5165\u6570\u7ec4 nums \u4e2d\uff0c\u5e76\u4fdd\u6301\u5176\u6709\u5e8f\u6027\u3002\u82e5\u6570\u7ec4\u4e2d\u5df2\u5b58\u5728\u5143\u7d20 target \uff0c\u5219\u63d2\u5165\u5230\u5176\u5de6\u65b9\u3002\u8bf7\u8fd4\u56de\u63d2\u5165\u540e target \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15\u3002\u793a\u4f8b\u5982\u56fe 10-4 \u6240\u793a\u3002

    \u56fe 10-4 \u00a0 \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\u793a\u4f8b\u6570\u636e

    \u5982\u679c\u60f3\u590d\u7528\u4e0a\u4e00\u8282\u7684\u4e8c\u5206\u67e5\u627e\u4ee3\u7801\uff0c\u5219\u9700\u8981\u56de\u7b54\u4ee5\u4e0b\u4e24\u4e2a\u95ee\u9898\u3002

    \u95ee\u9898\u4e00\uff1a\u5f53\u6570\u7ec4\u4e2d\u5305\u542b target \u65f6\uff0c\u63d2\u5165\u70b9\u7684\u7d22\u5f15\u662f\u5426\u662f\u8be5\u5143\u7d20\u7684\u7d22\u5f15\uff1f

    \u9898\u76ee\u8981\u6c42\u5c06 target \u63d2\u5165\u5230\u76f8\u7b49\u5143\u7d20\u7684\u5de6\u8fb9\uff0c\u8fd9\u610f\u5473\u7740\u65b0\u63d2\u5165\u7684 target \u66ff\u6362\u4e86\u539f\u6765 target \u7684\u4f4d\u7f6e\u3002\u4e5f\u5c31\u662f\u8bf4\uff0c\u5f53\u6570\u7ec4\u5305\u542b target \u65f6\uff0c\u63d2\u5165\u70b9\u7684\u7d22\u5f15\u5c31\u662f\u8be5 target \u7684\u7d22\u5f15\u3002

    \u95ee\u9898\u4e8c\uff1a\u5f53\u6570\u7ec4\u4e2d\u4e0d\u5b58\u5728 target \u65f6\uff0c\u63d2\u5165\u70b9\u662f\u54ea\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\uff1f

    \u8fdb\u4e00\u6b65\u601d\u8003\u4e8c\u5206\u67e5\u627e\u8fc7\u7a0b\uff1a\u5f53 nums[m] < target \u65f6 \\(i\\) \u79fb\u52a8\uff0c\u8fd9\u610f\u5473\u7740\u6307\u9488 \\(i\\) \u5728\u5411\u5927\u4e8e\u7b49\u4e8e target \u7684\u5143\u7d20\u9760\u8fd1\u3002\u540c\u7406\uff0c\u6307\u9488 \\(j\\) \u59cb\u7ec8\u5728\u5411\u5c0f\u4e8e\u7b49\u4e8e target \u7684\u5143\u7d20\u9760\u8fd1\u3002

    \u56e0\u6b64\u4e8c\u5206\u7ed3\u675f\u65f6\u4e00\u5b9a\u6709\uff1a\\(i\\) \u6307\u5411\u9996\u4e2a\u5927\u4e8e target \u7684\u5143\u7d20\uff0c\\(j\\) \u6307\u5411\u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u3002\u6613\u5f97\u5f53\u6570\u7ec4\u4e0d\u5305\u542b target \u65f6\uff0c\u63d2\u5165\u7d22\u5f15\u4e3a \\(i\\) \u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_insertion.py
    def binary_search_insertion_simple(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09\"\"\"\n    i, j = 0, len(nums) - 1  # \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while i <= j:\n        m = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target:\n            i = m + 1  # target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        elif nums[m] > target:\n            j = m - 1  # target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        else:\n            return m  # \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n    # \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n
    binary_search_insertion.cpp
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertionSimple(vector<int> &nums, int target) {\n    int i = 0, j = nums.size() - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.java
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.cs
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint BinarySearchInsertionSimple(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.go
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfunc binarySearchInsertionSimple(nums []int, target int) int {\n    // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    i, j := 0, len(nums)-1\n    for i <= j {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        m := i + (j-i)/2\n        if nums[m] < target {\n            // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        } else if nums[m] > target {\n            // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        } else {\n            // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n            return m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.swift
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfunc binarySearchInsertionSimple(nums: [Int], target: Int) -> Int {\n    // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i <= j {\n        let m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target {\n            i = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if nums[m] > target {\n            j = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.js
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfunction binarySearchInsertionSimple(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        const m = Math.floor(i + (j - i) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m, \u4f7f\u7528 Math.floor() \u5411\u4e0b\u53d6\u6574\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.ts
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfunction binarySearchInsertionSimple(\n    nums: Array<number>,\n    target: number\n): number {\n    let i = 0,\n        j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        const m = Math.floor(i + (j - i) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m, \u4f7f\u7528 Math.floor() \u5411\u4e0b\u53d6\u6574\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.dart
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertionSimple(List<int> nums, int target) {\n  int i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n  while (i <= j) {\n    int m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    if (nums[m] < target) {\n      i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n    } else if (nums[m] > target) {\n      j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n    } else {\n      return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n    }\n  }\n  // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n  return i;\n}\n
    binary_search_insertion.rs
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfn binary_search_insertion_simple(nums: &[i32], target: i32) -> i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while i <= j {\n        let m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m as usize] < target {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if nums[m as usize] > target {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m;\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    i\n}\n
    binary_search_insertion.c
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertionSimple(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m; // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.kt
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u65e0\u91cd\u590d\u5143\u7d20\uff09 */\nfun binarySearchInsertionSimple(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        val m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            return m // \u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 m\n        }\n    }\n    // \u672a\u627e\u5230 target \uff0c\u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.rb
    [class]{}-[func]{binary_search_insertion_simple}\n
    binary_search_insertion.zig
    [class]{}-[func]{binarySearchInsertionSimple}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_searching/binary_search_insertion/#1022","title":"10.2.2 \u00a0 \u5b58\u5728\u91cd\u590d\u5143\u7d20\u7684\u60c5\u51b5","text":"

    Question

    \u5728\u4e0a\u4e00\u9898\u7684\u57fa\u7840\u4e0a\uff0c\u89c4\u5b9a\u6570\u7ec4\u53ef\u80fd\u5305\u542b\u91cd\u590d\u5143\u7d20\uff0c\u5176\u4f59\u4e0d\u53d8\u3002

    \u5047\u8bbe\u6570\u7ec4\u4e2d\u5b58\u5728\u591a\u4e2a target \uff0c\u5219\u666e\u901a\u4e8c\u5206\u67e5\u627e\u53ea\u80fd\u8fd4\u56de\u5176\u4e2d\u4e00\u4e2a target \u7684\u7d22\u5f15\uff0c\u800c\u65e0\u6cd5\u786e\u5b9a\u8be5\u5143\u7d20\u7684\u5de6\u8fb9\u548c\u53f3\u8fb9\u8fd8\u6709\u591a\u5c11 target\u3002

    \u9898\u76ee\u8981\u6c42\u5c06\u76ee\u6807\u5143\u7d20\u63d2\u5165\u5230\u6700\u5de6\u8fb9\uff0c\u6240\u4ee5\u6211\u4eec\u9700\u8981\u67e5\u627e\u6570\u7ec4\u4e2d\u6700\u5de6\u4e00\u4e2a target \u7684\u7d22\u5f15\u3002\u521d\u6b65\u8003\u8651\u901a\u8fc7\u56fe 10-5 \u6240\u793a\u7684\u6b65\u9aa4\u5b9e\u73b0\u3002

    1. \u6267\u884c\u4e8c\u5206\u67e5\u627e\uff0c\u5f97\u5230\u4efb\u610f\u4e00\u4e2a target \u7684\u7d22\u5f15\uff0c\u8bb0\u4e3a \\(k\\) \u3002
    2. \u4ece\u7d22\u5f15 \\(k\\) \u5f00\u59cb\uff0c\u5411\u5de6\u8fdb\u884c\u7ebf\u6027\u904d\u5386\uff0c\u5f53\u627e\u5230\u6700\u5de6\u8fb9\u7684 target \u65f6\u8fd4\u56de\u3002

    \u56fe 10-5 \u00a0 \u7ebf\u6027\u67e5\u627e\u91cd\u590d\u5143\u7d20\u7684\u63d2\u5165\u70b9

    \u6b64\u65b9\u6cd5\u867d\u7136\u53ef\u7528\uff0c\u4f46\u5176\u5305\u542b\u7ebf\u6027\u67e5\u627e\uff0c\u56e0\u6b64\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \u3002\u5f53\u6570\u7ec4\u4e2d\u5b58\u5728\u5f88\u591a\u91cd\u590d\u7684 target \u65f6\uff0c\u8be5\u65b9\u6cd5\u6548\u7387\u5f88\u4f4e\u3002

    \u73b0\u8003\u8651\u62d3\u5c55\u4e8c\u5206\u67e5\u627e\u4ee3\u7801\u3002\u5982\u56fe 10-6 \u6240\u793a\uff0c\u6574\u4f53\u6d41\u7a0b\u4fdd\u6301\u4e0d\u53d8\uff0c\u6bcf\u8f6e\u5148\u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 \\(m\\) \uff0c\u518d\u5224\u65ad target \u548c nums[m] \u7684\u5927\u5c0f\u5173\u7cfb\uff0c\u5206\u4e3a\u4ee5\u4e0b\u51e0\u79cd\u60c5\u51b5\u3002

    • \u5f53 nums[m] < target \u6216 nums[m] > target \u65f6\uff0c\u8bf4\u660e\u8fd8\u6ca1\u6709\u627e\u5230 target \uff0c\u56e0\u6b64\u91c7\u7528\u666e\u901a\u4e8c\u5206\u67e5\u627e\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\u5c0f\u4e8e target \u7684\u5143\u7d20\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

    \u5faa\u73af\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\u7d22\u5f15 \\(i\\) \u5c31\u662f\u63d2\u5165\u70b9\u3002

    <1><2><3><4><5><6><7><8>

    \u56fe 10-6 \u00a0 \u4e8c\u5206\u67e5\u627e\u91cd\u590d\u5143\u7d20\u7684\u63d2\u5165\u70b9\u7684\u6b65\u9aa4

    \u89c2\u5bdf\u4ee5\u4e0b\u4ee3\u7801\uff0c\u5224\u65ad\u5206\u652f nums[m] > target \u548c nums[m] == target \u7684\u64cd\u4f5c\u76f8\u540c\uff0c\u56e0\u6b64\u4e24\u8005\u53ef\u4ee5\u5408\u5e76\u3002

    \u5373\u4fbf\u5982\u6b64\uff0c\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u5c06\u5224\u65ad\u6761\u4ef6\u4fdd\u6301\u5c55\u5f00\uff0c\u56e0\u4e3a\u5176\u903b\u8f91\u66f4\u52a0\u6e05\u6670\u3001\u53ef\u8bfb\u6027\u66f4\u597d\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_insertion.py
    def binary_search_insertion(nums: list[int], target: int) -> int:\n    \"\"\"\u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09\"\"\"\n    i, j = 0, len(nums) - 1  # \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while i <= j:\n        m = (i + j) // 2  # \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target:\n            i = m + 1  # target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        elif nums[m] > target:\n            j = m - 1  # target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        else:\n            j = m - 1  # \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n    # \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n
    binary_search_insertion.cpp
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertion(vector<int> &nums, int target) {\n    int i = 0, j = nums.size() - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.java
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.cs
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint BinarySearchInsertion(int[] nums, int target) {\n    int i = 0, j = nums.Length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.go
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfunc binarySearchInsertion(nums []int, target int) int {\n    // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    i, j := 0, len(nums)-1\n    for i <= j {\n        // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        m := i + (j-i)/2\n        if nums[m] < target {\n            // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n            i = m + 1\n        } else if nums[m] > target {\n            // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        } else {\n            // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n            j = m - 1\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.swift
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfunc binarySearchInsertion(nums: [Int], target: Int) -> Int {\n    // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    var i = nums.startIndex\n    var j = nums.endIndex - 1\n    while i <= j {\n        let m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m] < target {\n            i = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if nums[m] > target {\n            j = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1 // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.js
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfunction binarySearchInsertion(nums, target) {\n    let i = 0,\n        j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        const m = Math.floor(i + (j - i) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m, \u4f7f\u7528 Math.floor() \u5411\u4e0b\u53d6\u6574\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.ts
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfunction binarySearchInsertion(nums: Array<number>, target: number): number {\n    let i = 0,\n        j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        const m = Math.floor(i + (j - i) / 2); // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m, \u4f7f\u7528 Math.floor() \u5411\u4e0b\u53d6\u6574\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.dart
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertion(List<int> nums, int target) {\n  int i = 0, j = nums.length - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n  while (i <= j) {\n    int m = i + (j - i) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n    if (nums[m] < target) {\n      i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n    } else if (nums[m] > target) {\n      j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n    } else {\n      j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n    }\n  }\n  // \u8fd4\u56de\u63d2\u5165\u70b9 i\n  return i;\n}\n
    binary_search_insertion.rs
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\npub fn binary_search_insertion(nums: &[i32], target: i32) -> i32 {\n    let (mut i, mut j) = (0, nums.len() as i32 - 1); // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while i <= j {\n        let m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if nums[m as usize] < target {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if nums[m as usize] > target {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    i\n}\n
    binary_search_insertion.c
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nint binarySearchInsertion(int *nums, int numSize, int target) {\n    int i = 0, j = numSize - 1; // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        int m = i + (j - i) / 2; // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1; // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1; // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1; // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i;\n}\n
    binary_search_insertion.kt
    /* \u4e8c\u5206\u67e5\u627e\u63d2\u5165\u70b9\uff08\u5b58\u5728\u91cd\u590d\u5143\u7d20\uff09 */\nfun binarySearchInsertion(nums: IntArray, target: Int): Int {\n    var i = 0\n    var j = nums.size - 1 // \u521d\u59cb\u5316\u53cc\u95ed\u533a\u95f4 [0, n-1]\n    while (i <= j) {\n        val m = i + (j - i) / 2 // \u8ba1\u7b97\u4e2d\u70b9\u7d22\u5f15 m\n        if (nums[m] < target) {\n            i = m + 1 // target \u5728\u533a\u95f4 [m+1, j] \u4e2d\n        } else if (nums[m] > target) {\n            j = m - 1 // target \u5728\u533a\u95f4 [i, m-1] \u4e2d\n        } else {\n            j = m - 1 // \u9996\u4e2a\u5c0f\u4e8e target \u7684\u5143\u7d20\u5728\u533a\u95f4 [i, m-1] \u4e2d\n        }\n    }\n    // \u8fd4\u56de\u63d2\u5165\u70b9 i\n    return i\n}\n
    binary_search_insertion.rb
    [class]{}-[func]{binary_search_insertion}\n
    binary_search_insertion.zig
    [class]{}-[func]{binarySearchInsertion}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    Tip

    \u672c\u8282\u7684\u4ee3\u7801\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

    \u603b\u7684\u6765\u770b\uff0c\u4e8c\u5206\u67e5\u627e\u65e0\u975e\u5c31\u662f\u7ed9\u6307\u9488 \\(i\\) \u548c \\(j\\) \u5206\u522b\u8bbe\u5b9a\u641c\u7d22\u76ee\u6807\uff0c\u76ee\u6807\u53ef\u80fd\u662f\u4e00\u4e2a\u5177\u4f53\u7684\u5143\u7d20\uff08\u4f8b\u5982 target \uff09\uff0c\u4e5f\u53ef\u80fd\u662f\u4e00\u4e2a\u5143\u7d20\u8303\u56f4\uff08\u4f8b\u5982\u5c0f\u4e8e target \u7684\u5143\u7d20\uff09\u3002

    \u5728\u4e0d\u65ad\u7684\u5faa\u73af\u4e8c\u5206\u4e2d\uff0c\u6307\u9488 \\(i\\) \u548c \\(j\\) \u90fd\u9010\u6e10\u903c\u8fd1\u9884\u5148\u8bbe\u5b9a\u7684\u76ee\u6807\u3002\u6700\u7ec8\uff0c\u5b83\u4eec\u6216\u662f\u6210\u529f\u627e\u5230\u7b54\u6848\uff0c\u6216\u662f\u8d8a\u8fc7\u8fb9\u754c\u540e\u505c\u6b62\u3002

    "},{"location":"chapter_searching/replace_linear_by_hashing/","title":"10.4 \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/#1041","title":"10.4.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\u5982\u56fe 10-9 \u6240\u793a\uff0c\u6211\u4eec\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

    \u56fe 10-9 \u00a0 \u7ebf\u6027\u67e5\u627e\u6c42\u89e3\u4e24\u6570\u4e4b\u548c

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u4e3a O(n^2)\n    for i in range(len(nums) - 1):\n        for j in range(i + 1, len(nums)):\n            if nums[i] + nums[j] == target:\n                return [i, j]\n    return []\n
    two_sum.cpp
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nvector<int> twoSumBruteForce(vector<int> &nums, int target) {\n    int size = nums.size();\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (int i = 0; i < size - 1; i++) {\n        for (int j = i + 1; j < size; j++) {\n            if (nums[i] + nums[j] == target)\n                return {i, j};\n        }\n    }\n    return {};\n}\n
    two_sum.java
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint[] twoSumBruteForce(int[] nums, int target) {\n    int size = nums.length;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (int i = 0; i < size - 1; i++) {\n        for (int j = i + 1; j < size; j++) {\n            if (nums[i] + nums[j] == target)\n                return new int[] { i, j };\n        }\n    }\n    return new int[0];\n}\n
    two_sum.cs
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint[] TwoSumBruteForce(int[] nums, int target) {\n    int size = nums.Length;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (int i = 0; i < size - 1; i++) {\n        for (int j = i + 1; j < size; j++) {\n            if (nums[i] + nums[j] == target)\n                return [i, j];\n        }\n    }\n    return [];\n}\n
    two_sum.go
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunc twoSumBruteForce(nums []int, target int) []int {\n    size := len(nums)\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for i := 0; i < size-1; i++ {\n        for j := i + 1; i < size; j++ {\n            if nums[i]+nums[j] == target {\n                return []int{i, j}\n            }\n        }\n    }\n    return nil\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\u4e3a O(n^2)\n    for i in nums.indices.dropLast() {\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[i] + nums[j] == target {\n                return [i, j]\n            }\n        }\n    }\n    return [0]\n}\n
    two_sum.js
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunction twoSumBruteForce(nums, target) {\n    const n = nums.length;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (let i = 0; i < n; i++) {\n        for (let j = i + 1; j < n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n
    two_sum.ts
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfunction twoSumBruteForce(nums: number[], target: number): number[] {\n    const n = nums.length;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (let i = 0; i < n; i++) {\n        for (let j = i + 1; j < n; j++) {\n            if (nums[i] + nums[j] === target) {\n                return [i, j];\n            }\n        }\n    }\n    return [];\n}\n
    two_sum.dart
    /* \u65b9\u6cd5\u4e00\uff1a \u66b4\u529b\u679a\u4e3e */\nList<int> twoSumBruteForce(List<int> nums, int target) {\n  int size = nums.length;\n  // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n  for (var i = 0; i < size - 1; i++) {\n    for (var j = i + 1; j < size; j++) {\n      if (nums[i] + nums[j] == target) return [i, j];\n    }\n  }\n  return [0];\n}\n
    two_sum.rs
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\npub fn two_sum_brute_force(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {\n    let size = nums.len();\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for i in 0..size - 1 {\n        for j in i + 1..size {\n            if nums[i] + nums[j] == target {\n                return Some(vec![i as i32, j as i32]);\n            }\n        }\n    }\n    None\n}\n
    two_sum.c
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nint *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {\n    for (int i = 0; i < numsSize; ++i) {\n        for (int j = i + 1; j < numsSize; ++j) {\n            if (nums[i] + nums[j] == target) {\n                int *res = malloc(sizeof(int) * 2);\n                res[0] = i, res[1] = j;\n                *returnSize = 2;\n                return res;\n            }\n        }\n    }\n    *returnSize = 0;\n    return NULL;\n}\n
    two_sum.kt
    /* \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e */\nfun twoSumBruteForce(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    for (i in 0..<size - 1) {\n        for (j in i + 1..<size) {\n            if (nums[i] + nums[j] == target) return intArrayOf(i, j)\n        }\n    }\n    return IntArray(0)\n}\n
    two_sum.rb
    [class]{}-[func]{two_sum_brute_force}\n
    two_sum.zig
    // \u65b9\u6cd5\u4e00\uff1a\u66b4\u529b\u679a\u4e3e\nfn twoSumBruteForce(nums: []i32, target: i32) ?[2]i32 {\n    var size: usize = nums.len;\n    var i: usize = 0;\n    // \u4e24\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n^2)\n    while (i < size - 1) : (i += 1) {\n        var j = i + 1;\n        while (j < size) : (j += 1) {\n            if (nums[i] + nums[j] == target) {\n                return [_]i32{@intCast(i), @intCast(j)};\n            }\n        }\n    }\n    return null;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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/#1042","title":"10.4.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\u56fe 10-10 \u6240\u793a\u7684\u6b65\u9aa4\u3002

    1. \u5224\u65ad\u6570\u5b57 target - nums[i] \u662f\u5426\u5728\u54c8\u5e0c\u8868\u4e2d\uff0c\u82e5\u662f\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\u8fd9\u4e24\u4e2a\u5143\u7d20\u7684\u7d22\u5f15\u3002
    2. \u5c06\u952e\u503c\u5bf9 nums[i] \u548c\u7d22\u5f15 i \u6dfb\u52a0\u8fdb\u54c8\u5e0c\u8868\u3002
    <1><2><3>

    \u56fe 10-10 \u00a0 \u8f85\u52a9\u54c8\u5e0c\u8868\u6c42\u89e3\u4e24\u6570\u4e4b\u548c

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff0c\u4ec5\u9700\u5355\u5c42\u5faa\u73af\u5373\u53ef\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u4e3a O(n)\n    dic = {}\n    # \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for i in range(len(nums)):\n        if target - nums[i] in dic:\n            return [dic[target - nums[i]], i]\n        dic[nums[i]] = i\n    return []\n
    two_sum.cpp
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nvector<int> twoSumHashTable(vector<int> &nums, int target) {\n    int size = nums.size();\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    unordered_map<int, int> dic;\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (int i = 0; i < size; i++) {\n        if (dic.find(target - nums[i]) != dic.end()) {\n            return {dic[target - nums[i]], i};\n        }\n        dic.emplace(nums[i], i);\n    }\n    return {};\n}\n
    two_sum.java
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint[] twoSumHashTable(int[] nums, int target) {\n    int size = nums.length;\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    Map<Integer, Integer> dic = new HashMap<>();\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (int i = 0; i < size; i++) {\n        if (dic.containsKey(target - nums[i])) {\n            return new int[] { dic.get(target - nums[i]), i };\n        }\n        dic.put(nums[i], i);\n    }\n    return new int[0];\n}\n
    two_sum.cs
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint[] TwoSumHashTable(int[] nums, int target) {\n    int size = nums.Length;\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    Dictionary<int, int> dic = [];\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (int i = 0; i < size; i++) {\n        if (dic.ContainsKey(target - nums[i])) {\n            return [dic[target - nums[i]], i];\n        }\n        dic.Add(nums[i], i);\n    }\n    return [];\n}\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\u4e3a O(n)\n    hashTable := map[int]int{}\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for idx, val := range nums {\n        if preIdx, ok := hashTable[target-val]; ok {\n            return []int{preIdx, idx}\n        }\n        hashTable[val] = idx\n    }\n    return nil\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\u4e3a O(n)\n    var dic: [Int: Int] = [:]\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for i in nums.indices {\n        if let j = dic[target - nums[i]] {\n            return [j, i]\n        }\n        dic[nums[i]] = i\n    }\n    return [0]\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\u4e3a O(n)\n    let m = {};\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (let i = 0; i < nums.length; i++) {\n        if (m[target - nums[i]] !== undefined) {\n            return [m[target - nums[i]], i];\n        } else {\n            m[nums[i]] = i;\n        }\n    }\n    return [];\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\u4e3a O(n)\n    let m: Map<number, number> = new Map();\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (let i = 0; i < nums.length; i++) {\n        let index = m.get(target - nums[i]);\n        if (index !== undefined) {\n            return [index, i];\n        } else {\n            m.set(nums[i], i);\n        }\n    }\n    return [];\n}\n
    two_sum.dart
    /* \u65b9\u6cd5\u4e8c\uff1a \u8f85\u52a9\u54c8\u5e0c\u8868 */\nList<int> twoSumHashTable(List<int> nums, int target) {\n  int size = nums.length;\n  // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n  Map<int, int> dic = HashMap();\n  // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n  for (var i = 0; i < size; i++) {\n    if (dic.containsKey(target - nums[i])) {\n      return [dic[target - nums[i]]!, i];\n    }\n    dic.putIfAbsent(nums[i], () => i);\n  }\n  return [0];\n}\n
    two_sum.rs
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\npub fn two_sum_hash_table(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    let mut dic = HashMap::new();\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (i, num) in nums.iter().enumerate() {\n        match dic.get(&(target - num)) {\n            Some(v) => return Some(vec![*v as i32, i as i32]),\n            None => dic.insert(num, i as i32),\n        };\n    }\n    None\n}\n
    two_sum.c
    /* \u54c8\u5e0c\u8868 */\ntypedef struct {\n    int key;\n    int val;\n    UT_hash_handle hh; // \u57fa\u4e8e uthash.h \u5b9e\u73b0\n} HashTable;\n\n/* \u54c8\u5e0c\u8868\u67e5\u8be2 */\nHashTable *find(HashTable *h, int key) {\n    HashTable *tmp;\n    HASH_FIND_INT(h, &key, tmp);\n    return tmp;\n}\n\n/* \u54c8\u5e0c\u8868\u5143\u7d20\u63d2\u5165 */\nvoid insert(HashTable *h, int key, int val) {\n    HashTable *t = find(h, key);\n    if (t == NULL) {\n        HashTable *tmp = malloc(sizeof(HashTable));\n        tmp->key = key, tmp->val = val;\n        HASH_ADD_INT(h, key, tmp);\n    } else {\n        t->val = val;\n    }\n}\n\n/* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nint *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {\n    HashTable *hashtable = NULL;\n    for (int i = 0; i < numsSize; i++) {\n        HashTable *t = find(hashtable, target - nums[i]);\n        if (t != NULL) {\n            int *res = malloc(sizeof(int) * 2);\n            res[0] = t->val, res[1] = i;\n            *returnSize = 2;\n            return res;\n        }\n        insert(hashtable, nums[i], i);\n    }\n    *returnSize = 0;\n    return NULL;\n}\n
    two_sum.kt
    /* \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868 */\nfun twoSumHashTable(nums: IntArray, target: Int): IntArray {\n    val size = nums.size\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    val dic = HashMap<Int, Int>()\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    for (i in 0..<size) {\n        if (dic.containsKey(target - nums[i])) {\n            return intArrayOf(dic[target - nums[i]]!!, i)\n        }\n        dic[nums[i]] = i\n    }\n    return IntArray(0)\n}\n
    two_sum.rb
    [class]{}-[func]{two_sum_hash_table}\n
    two_sum.zig
    // \u65b9\u6cd5\u4e8c\uff1a\u8f85\u52a9\u54c8\u5e0c\u8868\nfn twoSumHashTable(nums: []i32, target: i32) !?[2]i32 {\n    var size: usize = nums.len;\n    // \u8f85\u52a9\u54c8\u5e0c\u8868\uff0c\u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    var dic = std.AutoHashMap(i32, i32).init(std.heap.page_allocator);\n    defer dic.deinit();\n    var i: usize = 0;\n    // \u5355\u5c42\u5faa\u73af\uff0c\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n)\n    while (i < size) : (i += 1) {\n        if (dic.contains(target - nums[i])) {\n            return [_]i32{dic.get(target - nums[i]).?, @intCast(i)};\n        }\n        try dic.put(nums[i], @intCast(i));\n    }\n    return null;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u6b64\u65b9\u6cd5\u901a\u8fc7\u54c8\u5e0c\u67e5\u627e\u5c06\u65f6\u95f4\u590d\u6742\u5ea6\u4ece \\(O(n^2)\\) \u964d\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.5 \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

    \u641c\u7d22\u7b97\u6cd5\u53ef\u6839\u636e\u5b9e\u73b0\u601d\u8def\u5206\u4e3a\u4ee5\u4e0b\u4e24\u7c7b\u3002

    • \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/#1051","title":"10.5.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

    • \u201c\u7ebf\u6027\u641c\u7d22\u201d\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
    • \u201c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22\u201d\u548c\u201c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u201d\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\u4ece\u521d\u59cb\u8282\u70b9\u5f00\u59cb\uff0c\u6cbf\u7740\u4e00\u6761\u8def\u5f84\u8d70\u5230\u5934\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\u987b\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/#1052","title":"10.5.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

    • \u201c\u4e8c\u5206\u67e5\u627e\u201d\u5229\u7528\u6570\u636e\u7684\u6709\u5e8f\u6027\u5b9e\u73b0\u9ad8\u6548\u67e5\u627e\uff0c\u4ec5\u9002\u7528\u4e8e\u6570\u7ec4\u3002
    • \u201c\u54c8\u5e0c\u67e5\u627e\u201d\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
    • \u201c\u6811\u67e5\u627e\u201d\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\u9500\u3002

    Tip

    \u81ea\u9002\u5e94\u641c\u7d22\u7b97\u6cd5\u5e38\u88ab\u79f0\u4e3a\u67e5\u627e\u7b97\u6cd5\uff0c\u4e3b\u8981\u7528\u4e8e\u5728\u7279\u5b9a\u6570\u636e\u7ed3\u6784\u4e2d\u5feb\u901f\u68c0\u7d22\u76ee\u6807\u5143\u7d20\u3002

    "},{"location":"chapter_searching/searching_algorithm_revisited/#1053","title":"10.5.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\u4ece\u4e2d\u641c\u7d22\u76ee\u6807\u5143\u7d20\u3002\u5404\u4e2a\u65b9\u6cd5\u7684\u5de5\u4f5c\u539f\u7406\u5982\u56fe 10-11 \u6240\u793a\u3002

    \u56fe 10-11 \u00a0 \u591a\u79cd\u641c\u7d22\u7b56\u7565

    \u4e0a\u8ff0\u51e0\u79cd\u65b9\u6cd5\u7684\u64cd\u4f5c\u6548\u7387\u4e0e\u7279\u6027\u5982\u8868 10-1 \u6240\u793a\u3002

    \u8868 10-1 \u00a0 \u67e5\u627e\u7b97\u6cd5\u6548\u7387\u5bf9\u6bd4

    \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

    \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\u987b\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\u5206\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\u7684\u5f00\u9500\u3002
    "},{"location":"chapter_searching/summary/","title":"10.6 \u00a0 \u5c0f\u7ed3","text":"
    • \u4e8c\u5206\u67e5\u627e\u4f9d\u8d56\u6570\u636e\u7684\u6709\u5e8f\u6027\uff0c\u901a\u8fc7\u5faa\u73af\u9010\u6b65\u7f29\u51cf\u4e00\u534a\u641c\u7d22\u533a\u95f4\u6765\u8fdb\u884c\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\u987b\u5bf9\u6570\u636e\u8fdb\u884c\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\u7528\u4e8e\u5bf9\u67e5\u8be2\u6548\u7387\u8981\u6c42\u8f83\u9ad8\u4e14\u65e0\u987b\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\u81f3 \\(O(1)\\) \u3002
    "},{"location":"chapter_sorting/","title":"\u7b2c 11 \u7ae0 \u00a0 \u6392\u5e8f","text":"

    Abstract

    \u6392\u5e8f\u72b9\u5982\u4e00\u628a\u5c06\u6df7\u4e71\u53d8\u4e3a\u79e9\u5e8f\u7684\u9b54\u6cd5\u94a5\u5319\uff0c\u4f7f\u6211\u4eec\u80fd\u4ee5\u66f4\u9ad8\u6548\u7684\u65b9\u5f0f\u7406\u89e3\u4e0e\u5904\u7406\u6570\u636e\u3002

    \u65e0\u8bba\u662f\u7b80\u5355\u7684\u5347\u5e8f\uff0c\u8fd8\u662f\u590d\u6742\u7684\u5206\u7c7b\u6392\u5217\uff0c\u6392\u5e8f\u90fd\u5411\u6211\u4eec\u5c55\u793a\u4e86\u6570\u636e\u7684\u548c\u8c10\u7f8e\u611f\u3002

    "},{"location":"chapter_sorting/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 11.1 \u00a0 \u6392\u5e8f\u7b97\u6cd5
    • 11.2 \u00a0 \u9009\u62e9\u6392\u5e8f
    • 11.3 \u00a0 \u5192\u6ce1\u6392\u5e8f
    • 11.4 \u00a0 \u63d2\u5165\u6392\u5e8f
    • 11.5 \u00a0 \u5feb\u901f\u6392\u5e8f
    • 11.6 \u00a0 \u5f52\u5e76\u6392\u5e8f
    • 11.7 \u00a0 \u5806\u6392\u5e8f
    • 11.8 \u00a0 \u6876\u6392\u5e8f
    • 11.9 \u00a0 \u8ba1\u6570\u6392\u5e8f
    • 11.10 \u00a0 \u57fa\u6570\u6392\u5e8f
    • 11.11 \u00a0 \u5c0f\u7ed3
    "},{"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

    \u5982\u56fe 11-4 \u6240\u793a\uff0c\u5192\u6ce1\u8fc7\u7a0b\u53ef\u4ee5\u5229\u7528\u5143\u7d20\u4ea4\u6362\u64cd\u4f5c\u6765\u6a21\u62df\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\u4e8c\u8005\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>

    \u56fe 11-4 \u00a0 \u5229\u7528\u5143\u7d20\u4ea4\u6362\u64cd\u4f5c\u6a21\u62df\u5192\u6ce1

    "},{"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\u5982\u56fe 11-5 \u6240\u793a\u3002

    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\u3002
    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\u987b\u6392\u5e8f\uff0c\u56e0\u6b64\u6570\u7ec4\u6392\u5e8f\u5b8c\u6210\u3002

    \u56fe 11-5 \u00a0 \u5192\u6ce1\u6392\u5e8f\u6d41\u7a0b

    \u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig bubble_sort.py
    def bubble_sort(nums: list[int]):\n    \"\"\"\u5192\u6ce1\u6392\u5e8f\"\"\"\n    n = len(nums)\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for 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\n        for j in range(i):\n            if nums[j] > nums[j + 1]:\n                # \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\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]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                // \u8fd9\u91cc\u4f7f\u7528\u4e86 std::swap() \u51fd\u6570\n                swap(nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\n
    bubble_sort.java
    /* \u5192\u6ce1\u6392\u5e8f */\nvoid bubbleSort(int[] nums) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\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]\n    for (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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n            }\n        }\n    }\n}\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]\n    for 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\n        for j := 0; j < i; j++ {\n            if nums[j] > nums[j+1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\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]\n    for i in nums.indices.dropFirst().reversed() {\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\n        for j in 0 ..< i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums.swapAt(j, j + 1)\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]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[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]\n    for (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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[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]\n  for (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\n    for (int j = 0; j < i; j++) {\n      if (nums[j] > nums[j + 1]) {\n        // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n      }\n    }\n  }\n}\n
    bubble_sort.rs
    /* \u5192\u6ce1\u6392\u5e8f */\nfn bubble_sort(nums: &mut [i32]) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in (1..nums.len()).rev() {\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\n        for j in 0..i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[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]\n    for (int i = 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n            }\n        }\n    }\n}\n
    bubble_sort.kt
    /* \u5192\u6ce1\u6392\u5e8f */\nfun bubbleSort(nums: IntArray) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (i in nums.size - 1 downTo 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\n        for (j in 0..<i) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j] = nums[j+1].also { nums[j+1] = nums[j] }\n            }\n        }\n    }\n}\n
    bubble_sort.rb
    [class]{}-[func]{bubble_sort}\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]\n    var i: usize = nums.len - 1;\n    while (i > 0) : (i -= 1) {\n        var 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\n        while (j < i) : (j += 1) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                var tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n            }\n        }\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u65f6\u95f4\u590d\u6742\u5ea6\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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig bubble_sort.py
    def bubble_sort_with_flag(nums: list[int]):\n    \"\"\"\u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09\"\"\"\n    n = len(nums)\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in range(n - 1, 0, -1):\n        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\n        for j in range(i):\n            if nums[j] > nums[j + 1]:\n                # \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j], nums[j + 1] = nums[j + 1], nums[j]\n                flag = True  # \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n        if not flag:\n            break  # \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\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]\n    for (int i = nums.size() - 1; i > 0; i--) {\n        bool 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                // \u8fd9\u91cc\u4f7f\u7528\u4e86 std::swap() \u51fd\u6570\n                swap(nums[j], nums[j + 1]);\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag)\n            break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n    }\n}\n
    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]\n    for (int i = nums.length - 1; i > 0; i--) {\n        boolean 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                int tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag)\n            break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\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]\n    for (int i = nums.Length - 1; i > 0; i--) {\n        bool 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);\n                flag = true;  // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag) break;     // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n    }\n}\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]\n    for i := len(nums) - 1; i > 0; i-- {\n        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\n        for j := 0; j < i; j++ {\n            if nums[j] > nums[j+1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j], nums[j+1] = nums[j+1], nums[j]\n                flag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if flag == false { // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n            break\n        }\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]\n    for i in nums.indices.dropFirst().reversed() {\n        var flag = false // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n        for j in 0 ..< i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums.swapAt(j, j + 1)\n                flag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if !flag { // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n            break\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]\n    for (let i = nums.length - 1; i > 0; i--) {\n        let 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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag) break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\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]\n    for (let i = nums.length - 1; i > 0; i--) {\n        let 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\n        for (let j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag) break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\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]\n  for (int i = nums.length - 1; i > 0; i--) {\n    bool 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\n    for (int j = 0; j < i; j++) {\n      if (nums[j] > nums[j + 1]) {\n        // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n        int tmp = nums[j];\n        nums[j] = nums[j + 1];\n        nums[j + 1] = tmp;\n        flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n      }\n    }\n    if (!flag) break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n  }\n}\n
    bubble_sort.rs
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09 */\nfn bubble_sort_with_flag(nums: &mut [i32]) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for i in (1..nums.len()).rev() {\n        let mut 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\n        for j in 0..i {\n            if nums[j] > nums[j + 1] {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                let tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true; // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if !flag {\n            break; // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n        };\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]\n    for (int i = size - 1; i > 0; i--) {\n        bool 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\n        for (int j = 0; j < i; j++) {\n            if (nums[j] > nums[j + 1]) {\n                int temp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = temp;\n                flag = true;\n            }\n        }\n        if (!flag)\n            break;\n    }\n}\n
    bubble_sort.kt
    /* \u5192\u6ce1\u6392\u5e8f\uff08\u6807\u5fd7\u4f18\u5316\uff09 */\nfun bubbleSortWithFlag(nums: IntArray) {\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [0, i]\n    for (i in nums.size - 1 downTo 1) {\n        var 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\n        for (j in 0..<i) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                nums[j] = nums[j + 1].also { nums[j] = nums[j + 1] }\n                flag = true // \u8bb0\u5f55\u4ea4\u6362\u5143\u7d20\n            }\n        }\n        if (!flag) break // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n    }\n}\n
    bubble_sort.rb
    [class]{}-[func]{bubble_sort_with_flag}\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]\n    var i: usize = nums.len - 1;\n    while (i > 0) : (i -= 1) {\n        var flag = false;   // \u521d\u59cb\u5316\u6807\u5fd7\u4f4d\n        var 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\n        while (j < i) : (j += 1) {\n            if (nums[j] > nums[j + 1]) {\n                // \u4ea4\u6362 nums[j] \u4e0e nums[j + 1]\n                var tmp = nums[j];\n                nums[j] = nums[j + 1];\n                nums[j + 1] = tmp;\n                flag = true;\n            }\n        }\n        if (!flag) break;   // \u6b64\u8f6e\u201c\u5192\u6ce1\u201d\u672a\u4ea4\u6362\u4efb\u4f55\u5143\u7d20\uff0c\u76f4\u63a5\u8df3\u51fa\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\\)\u3001\\(n - 2\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \uff0c\u603b\u548c\u4e3a \\((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\\) \u548c \\(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\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\u9636\u3002

    \u300c\u6876\u6392\u5e8f bucket sort\u300d\u662f\u5206\u6cbb\u7b56\u7565\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\u5176\u5143\u7d20\u662f\u8303\u56f4 \\([0, 1)\\) \u5185\u7684\u6d6e\u70b9\u6570\u3002\u6876\u6392\u5e8f\u7684\u6d41\u7a0b\u5982\u56fe 11-13 \u6240\u793a\u3002

    1. \u521d\u59cb\u5316 \\(k\\) \u4e2a\u6876\uff0c\u5c06 \\(n\\) \u4e2a\u5143\u7d20\u5206\u914d\u5230 \\(k\\) \u4e2a\u6876\u4e2d\u3002
    2. \u5bf9\u6bcf\u4e2a\u6876\u5206\u522b\u6267\u884c\u6392\u5e8f\uff08\u8fd9\u91cc\u91c7\u7528\u7f16\u7a0b\u8bed\u8a00\u7684\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff09\u3002
    3. \u6309\u7167\u6876\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u5408\u5e76\u7ed3\u679c\u3002

    \u56fe 11-13 \u00a0 \u6876\u6392\u5e8f\u7b97\u6cd5\u6d41\u7a0b

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig bucket_sort.py
    def bucket_sort(nums: list[float]):\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\n    k = len(nums) // 2\n    buckets = [[] for _ in range(k)]\n    # 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for num in nums:\n        # \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        i = int(num * k)\n        # \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].append(num)\n    # 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for 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\n        bucket.sort()\n    # 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    i = 0\n    for bucket in buckets:\n        for num in bucket:\n            nums[i] = num\n            i += 1\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\n    int k = nums.size() / 2;\n    vector<vector<float>> buckets(k);\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (float num : nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        int i = num * k;\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 bucket_idx\n        buckets[i].push_back(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        sort(bucket.begin(), bucket.end());\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    int i = 0;\n    for (vector<float> &bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\n}\n
    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\n    int k = nums.length / 2;\n    List<List<Float>> buckets = new ArrayList<>();\n    for (int i = 0; i < k; i++) {\n        buckets.add(new ArrayList<>());\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (float num : nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        int i = (int) (num * k);\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets.get(i).add(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        Collections.sort(bucket);\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    int i = 0;\n    for (List<Float> bucket : buckets) {\n        for (float num : bucket) {\n            nums[i++] = num;\n        }\n    }\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\n    int k = nums.Length / 2;\n    List<List<float>> buckets = [];\n    for (int i = 0; i < k; i++) {\n        buckets.Add([]);\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    foreach (float num in nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        int i = (int)(num * k);\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].Add(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    foreach (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\n        bucket.Sort();\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    int j = 0;\n    foreach (List<float> bucket in buckets) {\n        foreach (float num in bucket) {\n            nums[j++] = num;\n        }\n    }\n}\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\n    k := len(nums) / 2\n    buckets := make([][]float64, k)\n    for i := 0; i < k; i++ {\n        buckets[i] = make([]float64, 0)\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for _, num := range nums {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        i := int(num * float64(k))\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i] = append(buckets[i], num)\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for 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\n        sort.Float64s(buckets[i])\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    i := 0\n    for _, bucket := range buckets {\n        for _, num := range bucket {\n            nums[i] = num\n            i++\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\n    let k = nums.count / 2\n    var buckets = (0 ..< k).map { _ in [Double]() }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for num in nums {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        let i = Int(num * Double(k))\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].append(num)\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for 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\n        buckets[i].sort()\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    var i = nums.startIndex\n    for bucket in buckets {\n        for num in bucket {\n            nums[i] = num\n            i += 1\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\n    const k = nums.length / 2;\n    const buckets = [];\n    for (let i = 0; i < k; i++) {\n        buckets.push([]);\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (const num of nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        const i = Math.floor(num * k);\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].push(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        bucket.sort((a, b) => a - b);\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[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\n    const k = nums.length / 2;\n    const buckets: number[][] = [];\n    for (let i = 0; i < k; i++) {\n        buckets.push([]);\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (const num of nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        const i = Math.floor(num * k);\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].push(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        bucket.sort((a, b) => a - b);\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    let i = 0;\n    for (const bucket of buckets) {\n        for (const num of bucket) {\n            nums[i++] = num;\n        }\n    }\n}\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\n  int k = nums.length ~/ 2;\n  List<List<double>> buckets = List.generate(k, (index) => []);\n\n  // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n  for (double _num in nums) {\n    // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 _num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n    int i = (_num * k).toInt();\n    // \u5c06 _num \u6dfb\u52a0\u8fdb\u6876 bucket_idx\n    buckets[i].add(_num);\n  }\n  // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n  for (List<double> bucket in buckets) {\n    bucket.sort();\n  }\n  // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n  int i = 0;\n  for (List<double> bucket in buckets) {\n    for (double _num in bucket) {\n      nums[i++] = _num;\n    }\n  }\n}\n
    bucket_sort.rs
    /* \u6876\u6392\u5e8f */\nfn bucket_sort(nums: &mut [f64]) {\n    // \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\n    let k = nums.len() / 2;\n    let mut buckets = vec![vec![]; k];\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for &mut num in &mut *nums {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        let i = (num * k as f64) as usize;\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].push(num);\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for bucket in &mut buckets {\n        // \u4f7f\u7528\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\uff0c\u4e5f\u53ef\u4ee5\u66ff\u6362\u6210\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\n        bucket.sort_by(|a, b| a.partial_cmp(b).unwrap());\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    let mut i = 0;\n    for bucket in &mut buckets {\n        for &mut num in bucket {\n            nums[i] = num;\n            i += 1;\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\n    int k = size / 2;\n    float **buckets = calloc(k, sizeof(float *));\n    for (int i = 0; i < k; i++) {\n        // \u6bcf\u4e2a\u6876\u6700\u591a\u53ef\u4ee5\u5206\u914d size \u4e2a\u5143\u7d20\n        buckets[i] = calloc(size, sizeof(float));\n    }\n\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (int i = 0; i < size; i++) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        int bucket_idx = nums[i] * k;\n        int 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\n        while (buckets[bucket_idx][j] > 0 && buckets[bucket_idx][j] < nums[i]) {\n            j++;\n        }\n        float temp = nums[i];\n        while (j < size && buckets[bucket_idx][j] > 0) {\n            swap(&temp, &buckets[bucket_idx][j]);\n            j++;\n        }\n        buckets[bucket_idx][j] = temp;\n    }\n\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (int i = 0; i < k; i++) {\n        qsort(buckets[i], size, sizeof(float), compare_float);\n    }\n\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    for (int i = 0, j = 0; j < k; j++) {\n        for (int l = 0; l < size; l++) {\n            if (buckets[j][l] > 0) {\n                nums[i++] = buckets[j][l];\n            }\n        }\n    }\n\n    // \u91ca\u653e\u4e0a\u8ff0\u5206\u914d\u7684\u5185\u5b58\n    for (int i = 0; i < k; i++) {\n        free(buckets[i]);\n    }\n    free(buckets);\n}\n
    bucket_sort.kt
    /* \u6876\u6392\u5e8f */\nfun bucketSort(nums: FloatArray) {\n    // \u521d\u59cb\u5316 k = n/2 \u4e2a\u6876\uff0c\u9884\u671f\u5411\u6bcf\u4e2a\u6876\u5206\u914d 2 \u4e2a\u5143\u7d20\n    val k = nums.size / 2\n    val buckets = ArrayList<ArrayList<Float>>()\n    for (i in 0..<k) {\n        buckets.add(ArrayList())\n    }\n    // 1. \u5c06\u6570\u7ec4\u5143\u7d20\u5206\u914d\u5230\u5404\u4e2a\u6876\u4e2d\n    for (num in nums) {\n        // \u8f93\u5165\u6570\u636e\u8303\u56f4\u4e3a [0, 1)\uff0c\u4f7f\u7528 num * k \u6620\u5c04\u5230\u7d22\u5f15\u8303\u56f4 [0, k-1]\n        val i = (num * k).toInt()\n        // \u5c06 num \u6dfb\u52a0\u8fdb\u6876 i\n        buckets[i].add(num)\n    }\n    // 2. \u5bf9\u5404\u4e2a\u6876\u6267\u884c\u6392\u5e8f\n    for (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\n        bucket.sort()\n    }\n    // 3. \u904d\u5386\u6876\u5408\u5e76\u7ed3\u679c\n    var i = 0\n    for (bucket in buckets) {\n        for (num in bucket) {\n            nums[i++] = num\n        }\n    }\n}\n
    bucket_sort.rb
    [class]{}-[func]{bucket_sort}\n
    bucket_sort.zig
    [class]{}-[func]{bucketSort}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/bucket_sort/#1182","title":"11.8.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"

    \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

    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\u6240\u6709\u6876\u548c\u5143\u7d20\uff0c\u82b1\u8d39 \\(O(n + k)\\) \u65f6\u95f4\u3002
    • \u81ea\u9002\u5e94\u6392\u5e8f\uff1a\u5728\u6700\u5dee\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\u4e3a \\(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 \u4e2a\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\u6761\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

    \u5982\u56fe 11-14 \u6240\u793a\uff0c\u8fd9\u79cd\u65b9\u6cd5\u672c\u8d28\u4e0a\u662f\u521b\u5efa\u4e00\u68f5\u9012\u5f52\u6811\uff0c\u76ee\u6807\u662f\u8ba9\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

    \u56fe 11-14 \u00a0 \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\u56fe 11-15 \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

    \u56fe 11-15 \u00a0 \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\uff0c\u8ba1\u6570\u6392\u5e8f\u7684\u6574\u4f53\u6d41\u7a0b\u5982\u56fe 11-16 \u6240\u793a\u3002

    1. \u904d\u5386\u6570\u7ec4\uff0c\u627e\u51fa\u5176\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 \u3002
    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\u6392\u5e8f\u597d\u4e86\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u904d\u5386 counter \uff0c\u6839\u636e\u5404\u6570\u5b57\u51fa\u73b0\u6b21\u6570\u4ece\u5c0f\u5230\u5927\u7684\u987a\u5e8f\u586b\u5165 nums \u5373\u53ef\u3002

    \u56fe 11-16 \u00a0 \u8ba1\u6570\u6392\u5e8f\u6d41\u7a0b

    \u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig counting_sort.py
    def counting_sort_naive(nums: list[int]):\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\n    m = 0\n    for num in nums:\n        m = 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\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[num] += 1\n    # 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    i = 0\n    for num in range(m + 1):\n        for _ in range(counter[num]):\n            nums[i] = num\n            i += 1\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\n    int m = 0;\n    for (int num : nums) {\n        m = 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\n    vector<int> counter(m + 1, 0);\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    int i = 0;\n    for (int num = 0; num < m + 1; num++) {\n        for (int j = 0; j < counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\n
    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\n    int m = 0;\n    for (int num : nums) {\n        m = 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\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    int i = 0;\n    for (int num = 0; num < m + 1; num++) {\n        for (int j = 0; j < counter[num]; j++, i++) {\n            nums[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\n    int m = 0;\n    foreach (int num in nums) {\n        m = 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\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    int i = 0;\n    for (int num = 0; num < m + 1; num++) {\n        for (int j = 0; j < counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\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\n    m := 0\n    for _, num := range nums {\n        if num > m {\n            m = 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\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[num]++\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    for i, num := 0, 0; num < m+1; num++ {\n        for j := 0; j < counter[num]; j++ {\n            nums[i] = num\n            i++\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\n    let 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\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[num] += 1\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    var i = 0\n    for num in 0 ..< m + 1 {\n        for _ in 0 ..< counter[num] {\n            nums[i] = num\n            i += 1\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\n    let m = 0;\n    for (const num of nums) {\n        m = 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\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    let i = 0;\n    for (let num = 0; num < m + 1; num++) {\n        for (let j = 0; j < counter[num]; j++, i++) {\n            nums[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\n    let m = 0;\n    for (const num of nums) {\n        m = 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\n    const counter: number[] = new Array<number>(m + 1).fill(0);\n    for (const num of nums) {\n        counter[num]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    let i = 0;\n    for (let num = 0; num < m + 1; num++) {\n        for (let j = 0; j < counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n}\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\n  int m = 0;\n  for (int _num in nums) {\n    m = 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\n  List<int> counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_num]++;\n  }\n  // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n  int i = 0;\n  for (int _num = 0; _num < m + 1; _num++) {\n    for (int j = 0; j < counter[_num]; j++, i++) {\n      nums[i] = _num;\n    }\n  }\n}\n
    counting_sort.rs
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfn counting_sort_naive(nums: &mut [i32]) {\n    // 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\n    let m = *nums.into_iter().max().unwrap();\n    // 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    // counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\n    let mut counter = vec![0; m as usize + 1];\n    for &num in &*nums {\n        counter[num as usize] += 1;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    let mut i = 0;\n    for num in 0..m + 1 {\n        for _ in 0..counter[num as usize] {\n            nums[i] = num;\n            i += 1;\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\n    int m = 0;\n    for (int i = 0; i < size; i++) {\n        if (nums[i] > m) {\n            m = 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\n    int *counter = calloc(m + 1, sizeof(int));\n    for (int i = 0; i < size; i++) {\n        counter[nums[i]]++;\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    int i = 0;\n    for (int num = 0; num < m + 1; num++) {\n        for (int j = 0; j < counter[num]; j++, i++) {\n            nums[i] = num;\n        }\n    }\n    // 4. \u91ca\u653e\u5185\u5b58\n    free(counter);\n}\n
    counting_sort.kt
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u7b80\u5355\u5b9e\u73b0\uff0c\u65e0\u6cd5\u7528\u4e8e\u6392\u5e8f\u5bf9\u8c61\nfun countingSortNaive(nums: IntArray) {\n    // 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\n    var m = 0\n    for (num in nums) {\n        m = max(m.toDouble(), num.toDouble()).toInt()\n    }\n    // 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    // counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[num]++\n    }\n    // 3. \u904d\u5386 counter \uff0c\u5c06\u5404\u5143\u7d20\u586b\u5165\u539f\u6570\u7ec4 nums\n    var i = 0\n    for (num in 0..<m + 1) {\n        var j = 0\n        while (j < counter[num]) {\n            nums[i] = num\n            j++\n            i++\n        }\n    }\n}\n
    counting_sort.rb
    [class]{}-[func]{counting_sort_naive}\n
    counting_sort.zig
    [class]{}-[func]{countingSortNaive}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\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\u8bfb\u8005\u53ef\u80fd\u53d1\u73b0\u4e86\uff0c\u5982\u679c\u8f93\u5165\u6570\u636e\u662f\u5bf9\u8c61\uff0c\u4e0a\u8ff0\u6b65\u9aa4 3. \u5c31\u5931\u6548\u4e86\u3002\u5047\u8bbe\u8f93\u5165\u6570\u636e\u662f\u5546\u54c1\u5bf9\u8c61\uff0c\u6211\u4eec\u60f3\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\u201c\u524d\u7f00\u548c\u201d\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\uff1a

    \\[ \\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\u4ee5\u4e0b\u4e24\u6b65\u3002

    1. \u5c06 num \u586b\u5165\u6570\u7ec4 res \u7684\u7d22\u5f15 prefix[num] - 1 \u5904\u3002
    2. \u4ee4\u524d\u7f00\u548c prefix[num] \u51cf\u5c0f \\(1\\) \uff0c\u4ece\u800c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\u3002

    \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\u56fe 11-17 \u5c55\u793a\u4e86\u5b8c\u6574\u7684\u8ba1\u6570\u6392\u5e8f\u6d41\u7a0b\u3002

    <1><2><3><4><5><6><7><8>

    \u56fe 11-17 \u00a0 \u8ba1\u6570\u6392\u5e8f\u6b65\u9aa4

    \u8ba1\u6570\u6392\u5e8f\u7684\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig counting_sort.py
    def counting_sort(nums: list[int]):\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\n    m = 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\n    counter = [0] * (m + 1)\n    for num in nums:\n        counter[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\n    for i in range(m):\n        counter[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\n    n = len(nums)\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        num = nums[i]\n        res[counter[num] - 1] = num  # \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for i in range(n):\n        nums[i] = res[i]\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\n    int m = 0;\n    for (int num : nums) {\n        m = 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\n    vector<int> counter(m + 1, 0);\n    for (int num : nums) {\n        counter[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\n    for (int i = 0; i < m; i++) {\n        counter[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\n    int n = nums.size();\n    vector<int> res(n);\n    for (int i = n - 1; i >= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    nums = res;\n}\n
    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\n    int m = 0;\n    for (int num : nums) {\n        m = 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\n    int[] counter = new int[m + 1];\n    for (int num : nums) {\n        counter[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\n    for (int i = 0; i < m; i++) {\n        counter[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\n    int n = nums.length;\n    int[] res = new int[n];\n    for (int i = n - 1; i >= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (int i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\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\n    int m = 0;\n    foreach (int num in nums) {\n        m = 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\n    int[] counter = new int[m + 1];\n    foreach (int num in nums) {\n        counter[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\n    for (int i = 0; i < m; i++) {\n        counter[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\n    int n = nums.Length;\n    int[] res = new int[n];\n    for (int i = n - 1; i >= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (int i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\n}\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\n    m := 0\n    for _, num := range nums {\n        if num > m {\n            m = 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\n    counter := make([]int, m+1)\n    for _, num := range nums {\n        counter[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\n    for i := 0; i < m; i++ {\n        counter[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\n    n := len(nums)\n    res := make([]int, n)\n    for i := n - 1; i >= 0; i-- {\n        num := nums[i]\n        // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        res[counter[num]-1] = num\n        // \u4ee4\u524d\u7f00\u548c\u81ea\u51cf 1 \uff0c\u5f97\u5230\u4e0b\u6b21\u653e\u7f6e num \u7684\u7d22\u5f15\n        counter[num]--\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u6570\u7ec4 res \u8986\u76d6\u539f\u6570\u7ec4 nums\n    copy(nums, res)\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\n    let 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\n    var counter = Array(repeating: 0, count: m + 1)\n    for num in nums {\n        counter[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\n    for i in 0 ..< m {\n        counter[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\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let num = nums[i]\n        res[counter[num] - 1] = num // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\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\n    let m = 0;\n    for (const num of nums) {\n        m = 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\n    const counter = new Array(m + 1).fill(0);\n    for (const num of nums) {\n        counter[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\n    for (let i = 0; i < m; i++) {\n        counter[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\n    const n = nums.length;\n    const res = new Array(n);\n    for (let i = n - 1; i >= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (let i = 0; i < n; i++) {\n        nums[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\n    let m = 0;\n    for (const num of nums) {\n        m = 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\n    const counter: number[] = new Array<number>(m + 1).fill(0);\n    for (const num of nums) {\n        counter[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\n    for (let i = 0; i < m; i++) {\n        counter[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\n    const n = nums.length;\n    const res: number[] = new Array<number>(n);\n    for (let i = n - 1; i >= 0; i--) {\n        const num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (let i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\n}\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\n  int m = 0;\n  for (int _num in nums) {\n    m = 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\n  List<int> counter = List.filled(m + 1, 0);\n  for (int _num in nums) {\n    counter[_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\n  for (int i = 0; i < m; i++) {\n    counter[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\n  int n = nums.length;\n  List<int> res = List.filled(n, 0);\n  for (int i = n - 1; i >= 0; i--) {\n    int _num = nums[i];\n    res[counter[_num] - 1] = _num; // \u5c06 _num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n    counter[_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\n  nums.setAll(0, res);\n}\n
    counting_sort.rs
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfn counting_sort(nums: &mut [i32]) {\n    // 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\n    let m = *nums.into_iter().max().unwrap();\n    // 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    // counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\n    let mut counter = vec![0; m as usize + 1];\n    for &num in &*nums {\n        counter[num as usize] += 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\n    for i in 0..m as usize {\n        counter[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\n    let n = nums.len();\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let num = nums[i];\n        res[counter[num as usize] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[num as usize] -= 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\n    for i in 0..n {\n        nums[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\n    int m = 0;\n    for (int i = 0; i < size; i++) {\n        if (nums[i] > m) {\n            m = 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\n    int *counter = calloc(m, sizeof(int));\n    for (int i = 0; i < size; i++) {\n        counter[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\n    for (int i = 0; i < m; i++) {\n        counter[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\n    int *res = malloc(sizeof(int) * size);\n    for (int i = size - 1; i >= 0; i--) {\n        int num = nums[i];\n        res[counter[num] - 1] = num; // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    memcpy(nums, res, size * sizeof(int));\n    // 5. \u91ca\u653e\u5185\u5b58\n    free(counter);\n}\n
    counting_sort.kt
    /* \u8ba1\u6570\u6392\u5e8f */\n// \u5b8c\u6574\u5b9e\u73b0\uff0c\u53ef\u6392\u5e8f\u5bf9\u8c61\uff0c\u5e76\u4e14\u662f\u7a33\u5b9a\u6392\u5e8f\nfun countingSort(nums: IntArray) {\n    // 1. \u7edf\u8ba1\u6570\u7ec4\u6700\u5927\u5143\u7d20 m\n    var m = 0\n    for (num in nums) {\n        m = max(m.toDouble(), num.toDouble()).toInt()\n    }\n    // 2. \u7edf\u8ba1\u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    // counter[num] \u4ee3\u8868 num \u7684\u51fa\u73b0\u6b21\u6570\n    val counter = IntArray(m + 1)\n    for (num in nums) {\n        counter[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\n    for (i in 0..<m) {\n        counter[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\n    val n = nums.size\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val num = nums[i]\n        res[counter[num] - 1] = num // \u5c06 num \u653e\u7f6e\u5230\u5bf9\u5e94\u7d22\u5f15\u5904\n        counter[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\n    for (i in 0..<n) {\n        nums[i] = res[i]\n    }\n}\n
    counting_sort.rb
    [class]{}-[func]{counting_sort}\n
    counting_sort.zig
    [class]{}-[func]{countingSort}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/counting_sort/#1193","title":"11.9.3 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\u4e3a \\(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\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\u5c06\u5176\u7528\u4e8e\u5176\u4ed6\u7c7b\u578b\u7684\u6570\u636e\uff0c\u9700\u8981\u786e\u4fdd\u8fd9\u4e9b\u6570\u636e\u53ef\u4ee5\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\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\u201c\u5806\u201c\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\u3002

    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\u56fe 11-12 \u6240\u793a\u3002

    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. \u6b65\u548c\u7b2c 3. \u6b65\u3002\u5faa\u73af \\(n - 1\\) \u8f6e\u540e\uff0c\u5373\u53ef\u5b8c\u6210\u6570\u7ec4\u6392\u5e8f\u3002

    Tip

    \u5b9e\u9645\u4e0a\uff0c\u5143\u7d20\u51fa\u5806\u64cd\u4f5c\u4e2d\u4e5f\u5305\u542b\u7b2c 2. \u6b65\u548c\u7b2c 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>

    \u56fe 11-12 \u00a0 \u5806\u6392\u5e8f\u6b65\u9aa4

    \u5728\u4ee3\u7801\u5b9e\u73b0\u4e2d\uff0c\u6211\u4eec\u4f7f\u7528\u4e86\u4e0e\u201c\u5806\u201d\u7ae0\u8282\u76f8\u540c\u7684\u4ece\u9876\u81f3\u5e95\u5806\u5316 sift_down() \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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\"\"\"\n    while True:\n        # \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        l = 2 * i + 1\n        r = 2 * i + 2\n        ma = i\n        if l < n and nums[l] > nums[ma]:\n            ma = l\n        if r < n and nums[r] > nums[ma]:\n            ma = r\n        # \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i:\n            break\n        # \u4ea4\u6362\u4e24\u8282\u70b9\n        nums[i], nums[ma] = nums[ma], nums[i]\n        # \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n\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\n    for i in range(len(nums) // 2 - 1, -1, -1):\n        sift_down(nums, len(nums), i)\n    # \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for i in range(len(nums) - 1, 0, -1):\n        # \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        sift_down(nums, i, 0)\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) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l < n && nums[l] > nums[ma])\n            ma = l;\n        if (r < n && nums[r] > nums[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        swap(nums[i], nums[ma]);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (int i = nums.size() / 2 - 1; i >= 0; --i) {\n        siftDown(nums, nums.size(), i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (int i = nums.size() - 1; i > 0; --i) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        swap(nums[0], nums[i]);\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(nums, i, 0);\n    }\n}\n
    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) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l < n && nums[l] > nums[ma])\n            ma = l;\n        if (r < n && nums[r] > nums[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (int i = nums.length / 2 - 1; i >= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (int i = nums.length - 1; i > 0; i--) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(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) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l < n && nums[l] > nums[ma])\n            ma = l;\n        if (r < n && nums[r] > nums[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i)\n            break;\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        (nums[ma], nums[i]) = (nums[i], nums[ma]);\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (int i = nums.Length / 2 - 1; i >= 0; i--) {\n        SiftDown(nums, nums.Length, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (int i = nums.Length - 1; i > 0; i--) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        SiftDown(nums, i, 0);\n    }\n}\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) {\n    for true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        l := 2*i + 1\n        r := 2*i + 2\n        ma := i\n        if l < n && (*nums)[l] > (*nums)[ma] {\n            ma = l\n        }\n        if r < n && (*nums)[r] > (*nums)[ma] {\n            ma = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\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\n    for i := len(*nums)/2 - 1; i >= 0; i-- {\n        siftDown(nums, len(*nums), i)\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for i := len(*nums) - 1; i > 0; i-- {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        siftDown(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) {\n    var i = i\n    while true {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = 2 * i + 1\n        let r = 2 * i + 2\n        var ma = i\n        if l < n, nums[l] > nums[ma] {\n            ma = l\n        }\n        if r < n, nums[r] > nums[ma] {\n            ma = r\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        nums.swapAt(i, ma)\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\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\n    for i in stride(from: nums.count / 2 - 1, through: 0, by: -1) {\n        siftDown(nums: &nums, n: nums.count, i: i)\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for i in nums.indices.dropFirst().reversed() {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        nums.swapAt(0, i)\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(nums: &nums, n: i, 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) {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l < n && nums[l] > nums[ma]) {\n            ma = l;\n        }\n        if (r < n && nums[r] > nums[ma]) {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (let i = nums.length - 1; i > 0; i--) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        siftDown(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 {\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let ma = i;\n        if (l < n && nums[l] > nums[ma]) {\n            ma = l;\n        }\n        if (r < n && nums[r] > nums[ma]) {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma === i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        [nums[i], nums[ma]] = [nums[ma], nums[i]];\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {\n        siftDown(nums, nums.length, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (let i = nums.length - 1; i > 0; i--) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\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\n        siftDown(nums, i, 0);\n    }\n}\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) {\n  while (true) {\n    // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n    int l = 2 * i + 1;\n    int r = 2 * i + 2;\n    int ma = i;\n    if (l < n && nums[l] > nums[ma]) ma = l;\n    if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n    if (ma == i) break;\n    // \u4ea4\u6362\u4e24\u8282\u70b9\n    int temp = nums[i];\n    nums[i] = nums[ma];\n    nums[ma] = temp;\n    // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n    i = ma;\n  }\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\n  for (int i = nums.length ~/ 2 - 1; i >= 0; i--) {\n    siftDown(nums, nums.length, i);\n  }\n  // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n  for (int i = nums.length - 1; i > 0; i--) {\n    // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n    int tmp = nums[0];\n    nums[0] = nums[i];\n    nums[i] = tmp;\n    // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n    siftDown(nums, i, 0);\n  }\n}\n
    heap_sort.rs
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfn sift_down(nums: &mut [i32], n: usize, mut i: usize) {\n    loop {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        let l = 2 * i + 1;\n        let r = 2 * i + 2;\n        let mut ma = i;\n        if l < n && nums[l] > nums[ma] {\n            ma = l;\n        }\n        if r < n && nums[r] > nums[ma] {\n            ma = r;\n        }\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if ma == i {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        let temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\n}\n\n/* \u5806\u6392\u5e8f */\nfn heap_sort(nums: &mut [i32]) {\n    // \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for i in (0..=nums.len() / 2 - 1).rev() {\n        sift_down(nums, nums.len(), i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for i in (1..=nums.len() - 1).rev() {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        let tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        sift_down(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) {\n    while (1) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        int l = 2 * i + 1;\n        int r = 2 * i + 2;\n        int ma = i;\n        if (l < n && nums[l] > nums[ma])\n            ma = l;\n        if (r < n && nums[r] > nums[ma])\n            ma = r;\n        // \u82e5\u8282\u70b9 i \u6700\u5927\u6216\u7d22\u5f15 l, r \u8d8a\u754c\uff0c\u5219\u65e0\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) {\n            break;\n        }\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        int temp = nums[i];\n        nums[i] = nums[ma];\n        nums[ma] = temp;\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma;\n    }\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\n    for (int i = n / 2 - 1; i >= 0; --i) {\n        siftDown(nums, n, i);\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (int i = n - 1; i > 0; --i) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        int tmp = nums[0];\n        nums[0] = nums[i];\n        nums[i] = tmp;\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(nums, i, 0);\n    }\n}\n
    heap_sort.kt
    /* \u5806\u7684\u957f\u5ea6\u4e3a n \uff0c\u4ece\u8282\u70b9 i \u5f00\u59cb\uff0c\u4ece\u9876\u81f3\u5e95\u5806\u5316 */\nfun siftDown(nums: IntArray, n: Int, li: Int) {\n    var i = li\n    while (true) {\n        // \u5224\u65ad\u8282\u70b9 i, l, r \u4e2d\u503c\u6700\u5927\u7684\u8282\u70b9\uff0c\u8bb0\u4e3a ma\n        val l = 2 * i + 1\n        val r = 2 * i + 2\n        var ma = i\n        if (l < n && nums[l] > nums[ma]) ma = l\n        if (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\u987b\u7ee7\u7eed\u5806\u5316\uff0c\u8df3\u51fa\n        if (ma == i) break\n        // \u4ea4\u6362\u4e24\u8282\u70b9\n        nums[i] = nums[ma].also { nums[ma] = nums[i] }\n        // \u5faa\u73af\u5411\u4e0b\u5806\u5316\n        i = ma\n    }\n}\n\n/* \u5806\u6392\u5e8f */\nfun heapSort(nums: IntArray) {\n    // \u5efa\u5806\u64cd\u4f5c\uff1a\u5806\u5316\u9664\u53f6\u8282\u70b9\u4ee5\u5916\u7684\u5176\u4ed6\u6240\u6709\u8282\u70b9\n    for (i in nums.size / 2 - 1 downTo 0) {\n        siftDown(nums, nums.size, i)\n    }\n    // \u4ece\u5806\u4e2d\u63d0\u53d6\u6700\u5927\u5143\u7d20\uff0c\u5faa\u73af n-1 \u8f6e\n    for (i in nums.size - 1 downTo 1) {\n        // \u4ea4\u6362\u6839\u8282\u70b9\u4e0e\u6700\u53f3\u53f6\u8282\u70b9\uff08\u4ea4\u6362\u9996\u5143\u7d20\u4e0e\u5c3e\u5143\u7d20\uff09\n        nums[0] = nums[i].also { nums[i] = nums[0] }\n        // \u4ee5\u6839\u8282\u70b9\u4e3a\u8d77\u70b9\uff0c\u4ece\u9876\u81f3\u5e95\u8fdb\u884c\u5806\u5316\n        siftDown(nums, i, 0)\n    }\n}\n
    heap_sort.rb
    [class]{}-[func]{sift_down}\n\n[class]{}-[func]{heap_sort}\n
    heap_sort.zig
    [class]{}-[func]{siftDown}\n\n[class]{}-[func]{heapSort}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/heap_sort/#1172","title":"11.7.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\u4e3a \\(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

    \u56fe 11-6 \u5c55\u793a\u4e86\u6570\u7ec4\u63d2\u5165\u5143\u7d20\u7684\u64cd\u4f5c\u6d41\u7a0b\u3002\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\u5c06 base \u8d4b\u503c\u7ed9\u76ee\u6807\u7d22\u5f15\u3002

    \u56fe 11-6 \u00a0 \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\u56fe 11-7 \u6240\u793a\u3002

    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

    \u56fe 11-7 \u00a0 \u63d2\u5165\u6392\u5e8f\u6d41\u7a0b

    \u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig insertion_sort.py
    def insertion_sort(nums: list[int]):\n    \"\"\"\u63d2\u5165\u6392\u5e8f\"\"\"\n    # \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for i in range(1, len(nums)):\n        base = nums[i]\n        j = 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\n        while j >= 0 and nums[j] > base:\n            nums[j + 1] = nums[j]  # \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j -= 1\n        nums[j + 1] = base  # \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n
    insertion_sort.cpp
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(vector<int> &nums) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for (int i = 1; i < nums.size(); i++) {\n        int base = nums[i], j = 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\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    insertion_sort.java
    /* \u63d2\u5165\u6392\u5e8f */\nvoid insertionSort(int[] nums) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for (int i = 1; i < nums.length; i++) {\n        int base = nums[i], j = 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\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[j + 1] = base;        // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    insertion_sort.cs
    /* \u63d2\u5165\u6392\u5e8f */\nvoid InsertionSort(int[] nums) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for (int i = 1; i < nums.Length; i++) {\n        int bas = nums[i], j = 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\n        while (j >= 0 && nums[j] > bas) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[j + 1] = bas;         // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    insertion_sort.go
    /* \u63d2\u5165\u6392\u5e8f */\nfunc insertionSort(nums []int) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for i := 1; i < len(nums); i++ {\n        base := nums[i]\n        j := 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\n        for j >= 0 && nums[j] > base {\n            nums[j+1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--\n        }\n        nums[j+1] = base // \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\u533a\u95f4\u4e3a [0, i-1]\n    for i in nums.indices.dropFirst() {\n        let base = nums[i]\n        var j = 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\n        while j >= 0, nums[j] > base {\n            nums[j + 1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j -= 1\n        }\n        nums[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\u533a\u95f4\u4e3a [0, i-1]\n    for (let i = 1; i < nums.length; i++) {\n        let base = nums[i],\n            j = 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\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[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\u533a\u95f4\u4e3a [0, i-1]\n    for (let i = 1; i < nums.length; i++) {\n        const base = nums[i];\n        let j = 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\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--;\n        }\n        nums[j + 1] = 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\u533a\u95f4\u4e3a [0, i-1]\n  for (int i = 1; i < nums.length; i++) {\n    int base = nums[i], j = 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\n    while (j >= 0 && nums[j] > base) {\n      nums[j + 1] = nums[j]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n      j--;\n    }\n    nums[j + 1] = base; // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n  }\n}\n
    insertion_sort.rs
    /* \u63d2\u5165\u6392\u5e8f */\nfn insertion_sort(nums: &mut [i32]) {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    for i in 1..nums.len() {\n        let (base, mut j) = (nums[i], (i - 1) as i32);\n        // \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u533a\u95f4 [0, i-1] \u4e2d\u7684\u6b63\u786e\u4f4d\u7f6e\n        while j >= 0 && nums[j as usize] > base {\n            nums[(j + 1) as usize] = nums[j as usize]; // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j -= 1;\n        }\n        nums[(j + 1) as usize] = 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\u533a\u95f4\u4e3a [0, i-1]\n    for (int i = 1; i < size; i++) {\n        int base = nums[i], j = 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\n        while (j >= 0 && nums[j] > base) {\n            // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            nums[j + 1] = nums[j];\n            j--;\n        }\n        // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n        nums[j + 1] = base;\n    }\n}\n
    insertion_sort.kt
    /* \u63d2\u5165\u6392\u5e8f */\nfun insertionSort(nums: IntArray) {\n    //\u5916\u5faa\u73af: \u5df2\u6392\u5e8f\u5143\u7d20\u4e3a 1, 2, ..., n\n    for (i in nums.indices) {\n        val base = nums[i]\n        var j = i - 1\n        // \u5185\u5faa\u73af: \u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u90e8\u5206\u7684\u6b63\u786e\u4f4d\u7f6e\n        while (j >= 0 && nums[j] > base) {\n            nums[j + 1] = nums[j] // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n            j--\n        }\n        nums[j + 1] = base        // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    insertion_sort.rb
    [class]{}-[func]{insertion_sort}\n
    insertion_sort.zig
    // \u63d2\u5165\u6392\u5e8f\nfn insertionSort(nums: []i32) void {\n    // \u5916\u5faa\u73af\uff1a\u5df2\u6392\u5e8f\u533a\u95f4\u4e3a [0, i-1]\n    var i: usize = 1;\n    while (i < nums.len) : (i += 1) {\n        var base = nums[i];\n        var j: usize = i;\n        // \u5185\u5faa\u73af\uff1a\u5c06 base \u63d2\u5165\u5230\u5df2\u6392\u5e8f\u533a\u95f4 [0, i-1] \u4e2d\u7684\u6b63\u786e\u4f4d\u7f6e\n        while (j >= 1 and nums[j - 1] > base) : (j -= 1) {\n            nums[j] = nums[j - 1];  // \u5c06 nums[j] \u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n        }\n        nums[j] = base;             // \u5c06 base \u8d4b\u503c\u5230\u6b63\u786e\u4f4d\u7f6e\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/insertion_sort/#1142","title":"11.4.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n^2)\\)\u3001\u81ea\u9002\u5e94\u6392\u5e8f\uff1a\u5728\u6700\u5dee\u60c5\u51b5\u4e0b\uff0c\u6bcf\u6b21\u63d2\u5165\u64cd\u4f5c\u5206\u522b\u9700\u8981\u5faa\u73af \\(n - 1\\)\u3001\\(n-2\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \u6b21\uff0c\u6c42\u548c\u5f97\u5230 \\((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\u4e3a \\(O(1)\\)\u3001\u539f\u5730\u6392\u5e8f\uff1a\u6307\u9488 \\(i\\) \u548c \\(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\u7684\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\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\u7b56\u7565\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\u5730\u4f4d\uff0c\u6bcf\u8f6e\u4e2d\u7684\u5355\u5143\u64cd\u4f5c\u6570\u91cf\u8d77\u5230\u51b3\u5b9a\u6027\u4f5c\u7528\u3002

    \u5b9e\u9645\u4e0a\uff0c\u8bb8\u591a\u7f16\u7a0b\u8bed\u8a00\uff08\u4f8b\u5982 Java\uff09\u7684\u5185\u7f6e\u6392\u5e8f\u51fd\u6570\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\u7b56\u7565\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\uff0c\u4e3b\u8981\u6709\u4ee5\u4e0b\u539f\u56e0\u3002

    • \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\u662f\u4e00\u79cd\u57fa\u4e8e\u5206\u6cbb\u7b56\u7565\u7684\u6392\u5e8f\u7b97\u6cd5\uff0c\u5305\u542b\u56fe 11-10 \u6240\u793a\u7684\u201c\u5212\u5206\u201d\u548c\u201c\u5408\u5e76\u201d\u9636\u6bb5\u3002

    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\u3002
    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\u3002

    \u56fe 11-10 \u00a0 \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":"

    \u5982\u56fe 11-11 \u6240\u793a\uff0c\u201c\u5212\u5206\u9636\u6bb5\u201d\u4ece\u9876\u81f3\u5e95\u9012\u5f52\u5730\u5c06\u6570\u7ec4\u4ece\u4e2d\u70b9\u5207\u5206\u4e3a\u4e24\u4e2a\u5b50\u6570\u7ec4\u3002

    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\u3002
    2. \u9012\u5f52\u6267\u884c\u6b65\u9aa4 1. \uff0c\u76f4\u81f3\u5b50\u6570\u7ec4\u533a\u95f4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u3002

    \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>

    \u56fe 11-11 \u00a0 \u5f52\u5e76\u6392\u5e8f\u6b65\u9aa4

    \u89c2\u5bdf\u53d1\u73b0\uff0c\u5f52\u5e76\u6392\u5e8f\u4e0e\u4e8c\u53c9\u6811\u540e\u5e8f\u904d\u5386\u7684\u9012\u5f52\u987a\u5e8f\u662f\u4e00\u81f4\u7684\u3002

    • \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

    \u5f52\u5e76\u6392\u5e8f\u7684\u5b9e\u73b0\u5982\u4ee5\u4e0b\u4ee3\u7801\u6240\u793a\u3002\u8bf7\u6ce8\u610f\uff0cnums \u7684\u5f85\u5408\u5e76\u533a\u95f4\u4e3a [left, right] \uff0c\u800c tmp \u7684\u5bf9\u5e94\u533a\u95f4\u4e3a [0, right - left] \u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig merge_sort.py
    def merge(nums: list[int], left: int, mid: int, right: int):\n    \"\"\"\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\"\"\"\n    # \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    # \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    tmp = [0] * (right - left + 1)\n    # \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    i, j, k = left, mid + 1, 0\n    # \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid and j <= right:\n        if nums[i] <= nums[j]:\n            tmp[k] = nums[i]\n            i += 1\n        else:\n            tmp[k] = nums[j]\n            j += 1\n        k += 1\n    # \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid:\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    while j <= right:\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    # \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for k in range(0, len(tmp)):\n        nums[left + k] = tmp[k]\n\ndef merge_sort(nums: list[int], left: int, right: int):\n    \"\"\"\u5f52\u5e76\u6392\u5e8f\"\"\"\n    # \u7ec8\u6b62\u6761\u4ef6\n    if left >= right:\n        return  # \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    # \u5212\u5206\u9636\u6bb5\n    mid = (left + right) // 2  # \u8ba1\u7b97\u4e2d\u70b9\n    merge_sort(nums, left, mid)  # \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    merge_sort(nums, mid + 1, right)  # \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    # \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right)\n
    merge_sort.cpp
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid merge(vector<int> &nums, int left, int mid, int right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    vector<int> tmp(right - left + 1);\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    int i = left, j = mid + 1, k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.size(); k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(vector<int> &nums, int left, int right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right)\n        return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    int mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.java
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid merge(int[] nums, int left, int mid, int right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    int[] tmp = new int[right - left + 1];\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    int i = left, j = mid + 1, k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int[] nums, int left, int right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right)\n        return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    int mid = (left + right) / 2; // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.cs
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid Merge(int[] nums, int left, int mid, int right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    int[] tmp = new int[right - left + 1];\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    int i = left, j = mid + 1, k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j])\n            tmp[k++] = nums[i++];\n        else\n            tmp[k++] = nums[j++];\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.Length; ++k) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid MergeSort(int[] nums, int left, int right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return;       // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    int mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\n    MergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    MergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    Merge(nums, left, mid, right);\n}\n
    merge_sort.go
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfunc merge(nums []int, left, mid, right int) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    tmp := make([]int, right-left+1)\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    i, j, k := left, mid+1, 0\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    for i <= mid && j <= right {\n        if nums[i] <= nums[j] {\n            tmp[k] = nums[i]\n            i++\n        } else {\n            tmp[k] = nums[j]\n            j++\n        }\n        k++\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    for i <= mid {\n        tmp[k] = nums[i]\n        i++\n        k++\n    }\n    for j <= right {\n        tmp[k] = nums[j]\n        j++\n        k++\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for k := 0; k < len(tmp); k++ {\n        nums[left+k] = tmp[k]\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfunc mergeSort(nums []int, left, right int) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if left >= right {\n        return\n    }\n    // \u5212\u5206\u9636\u6bb5\n    mid := (left + right) / 2\n    mergeSort(nums, left, mid)\n    mergeSort(nums, mid+1, right)\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right)\n}\n
    merge_sort.swift
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfunc merge(nums: inout [Int], left: Int, mid: Int, right: Int) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    var tmp = Array(repeating: 0, count: right - left + 1)\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    var i = left, j = mid + 1, k = 0\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid, j <= right {\n        if nums[i] <= nums[j] {\n            tmp[k] = nums[i]\n            i += 1\n        } else {\n            tmp[k] = nums[j]\n            j += 1\n        }\n        k += 1\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid {\n        tmp[k] = nums[i]\n        i += 1\n        k += 1\n    }\n    while j <= right {\n        tmp[k] = nums[j]\n        j += 1\n        k += 1\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for k in tmp.indices {\n        nums[left + k] = tmp[k]\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfunc mergeSort(nums: inout [Int], left: Int, right: Int) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if left >= right { // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n        return\n    }\n    // \u5212\u5206\u9636\u6bb5\n    let mid = (left + right) / 2 // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums: &nums, left: left, right: mid) // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums: &nums, left: mid + 1, right: right) // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums: &nums, left: left, mid: mid, right: right)\n}\n
    merge_sort.js
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfunction merge(nums, left, mid, right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    const tmp = new Array(right - left + 1);\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfunction mergeSort(nums, left, right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    let mid = Math.floor((left + right) / 2); // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.ts
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfunction merge(nums: number[], left: number, mid: number, right: number): void {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    const tmp = new Array(right - left + 1);\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    let i = left,\n        j = mid + 1,\n        k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmp.length; k++) {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfunction mergeSort(nums: number[], left: number, right: number): void {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    let mid = Math.floor((left + right) / 2); // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.dart
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid merge(List<int> nums, int left, int mid, int right) {\n  // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n  // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n  List<int> tmp = List.filled(right - left + 1, 0);\n  // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n  int i = left, j = mid + 1, k = 0;\n  // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n  while (i <= mid && j <= right) {\n    if (nums[i] <= nums[j])\n      tmp[k++] = nums[i++];\n    else\n      tmp[k++] = nums[j++];\n  }\n  // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n  while (i <= mid) {\n    tmp[k++] = nums[i++];\n  }\n  while (j <= right) {\n    tmp[k++] = nums[j++];\n  }\n  // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n  for (k = 0; k < tmp.length; k++) {\n    nums[left + k] = tmp[k];\n  }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(List<int> nums, int left, int right) {\n  // \u7ec8\u6b62\u6761\u4ef6\n  if (left >= right) return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n  // \u5212\u5206\u9636\u6bb5\n  int mid = (left + right) ~/ 2; // \u8ba1\u7b97\u4e2d\u70b9\n  mergeSort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n  mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n  // \u5408\u5e76\u9636\u6bb5\n  merge(nums, left, mid, right);\n}\n
    merge_sort.rs
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfn merge(nums: &mut [i32], left: usize, mid: usize, right: usize) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    let tmp_size = right - left + 1;\n    let mut tmp = vec![0; tmp_size];\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    let (mut i, mut j, mut k) = (left, mid + 1, 0);\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid && j <= right {\n        if nums[i] <= nums[j] {\n            tmp[k] = nums[i];\n            i += 1;\n        } else {\n            tmp[k] = nums[j];\n            j += 1;\n        }\n        k += 1;\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while i <= mid {\n        tmp[k] = nums[i];\n        k += 1;\n        i += 1;\n    }\n    while j <= right {\n        tmp[k] = nums[j];\n        k += 1;\n        j += 1;\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for k in 0..tmp_size {\n        nums[left + k] = tmp[k];\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfn merge_sort(nums: &mut [i32], left: usize, right: usize) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if left >= right {\n        return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    }\n\n    // \u5212\u5206\u9636\u6bb5\n    let mid = (left + right) / 2; // \u8ba1\u7b97\u4e2d\u70b9\n    merge_sort(nums, left, mid); // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    merge_sort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.c
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nvoid merge(int *nums, int left, int mid, int right) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    int tmpSize = right - left + 1;\n    int *tmp = (int *)malloc(tmpSize * sizeof(int));\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    int i = left, j = mid + 1, k = 0;\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j]) {\n            tmp[k++] = nums[i++];\n        } else {\n            tmp[k++] = nums[j++];\n        }\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++];\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++];\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (k = 0; k < tmpSize; ++k) {\n        nums[left + k] = tmp[k];\n    }\n    // \u91ca\u653e\u5185\u5b58\n    free(tmp);\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nvoid mergeSort(int *nums, int left, int right) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right)\n        return; // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    int mid = (left + right) / 2;    // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid);      // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right); // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right);\n}\n
    merge_sort.kt
    /* \u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4 */\nfun merge(nums: IntArray, left: Int, mid: Int, right: Int) {\n    // \u5de6\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [left, mid], \u53f3\u5b50\u6570\u7ec4\u533a\u95f4\u4e3a [mid+1, right]\n    // \u521b\u5efa\u4e00\u4e2a\u4e34\u65f6\u6570\u7ec4 tmp \uff0c\u7528\u4e8e\u5b58\u653e\u5408\u5e76\u540e\u7684\u7ed3\u679c\n    val tmp = IntArray(right - left + 1)\n    // \u521d\u59cb\u5316\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\n    var i = left\n    var j = mid + 1\n    var k = 0\n    // \u5f53\u5de6\u53f3\u5b50\u6570\u7ec4\u90fd\u8fd8\u6709\u5143\u7d20\u65f6\uff0c\u8fdb\u884c\u6bd4\u8f83\u5e76\u5c06\u8f83\u5c0f\u7684\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid && j <= right) {\n        if (nums[i] <= nums[j]) tmp[k++] = nums[i++]\n        else tmp[k++] = nums[j++]\n    }\n    // \u5c06\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u7684\u5269\u4f59\u5143\u7d20\u590d\u5236\u5230\u4e34\u65f6\u6570\u7ec4\u4e2d\n    while (i <= mid) {\n        tmp[k++] = nums[i++]\n    }\n    while (j <= right) {\n        tmp[k++] = nums[j++]\n    }\n    // \u5c06\u4e34\u65f6\u6570\u7ec4 tmp \u4e2d\u7684\u5143\u7d20\u590d\u5236\u56de\u539f\u6570\u7ec4 nums \u7684\u5bf9\u5e94\u533a\u95f4\n    for (l in tmp.indices) {\n        nums[left + l] = tmp[l]\n    }\n}\n\n/* \u5f52\u5e76\u6392\u5e8f */\nfun mergeSort(nums: IntArray, left: Int, right: Int) {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return  // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    val mid = (left + right) / 2 // \u8ba1\u7b97\u4e2d\u70b9\n    mergeSort(nums, left, mid) // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    mergeSort(nums, mid + 1, right) // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    merge(nums, left, mid, right)\n}\n
    merge_sort.rb
    [class]{}-[func]{merge}\n\n[class]{}-[func]{merge_sort}\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\n    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);\n    defer mem_arena.deinit();\n    const mem_allocator = mem_arena.allocator();\n    var tmp = try mem_allocator.alloc(i32, right + 1 - left);\n    std.mem.copy(i32, tmp, nums[left..right+1]);\n    // \u5de6\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15  \n    var leftStart = left - left;\n    var leftEnd = mid - left;\n    // \u53f3\u5b50\u6570\u7ec4\u7684\u8d77\u59cb\u7d22\u5f15\u548c\u7ed3\u675f\u7d22\u5f15       \n    var rightStart = mid + 1 - left;\n    var rightEnd = right - left;\n    // i, j \u5206\u522b\u6307\u5411\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\u7684\u9996\u5143\u7d20\n    var i = leftStart;\n    var j = rightStart;\n    // \u901a\u8fc7\u8986\u76d6\u539f\u6570\u7ec4 nums \u6765\u5408\u5e76\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\n    var k = left;\n    while (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++\n        if (i > leftEnd) {\n            nums[k] = tmp[j];\n            j += 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]) {\n            nums[k] = tmp[i];\n            i += 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 {\n            nums[k] = tmp[j];\n            j += 1;\n        }\n    }\n}\n\n// \u5f52\u5e76\u6392\u5e8f\nfn mergeSort(nums: []i32, left: usize, right: usize) !void {\n    // \u7ec8\u6b62\u6761\u4ef6\n    if (left >= right) return;              // \u5f53\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    // \u5212\u5206\u9636\u6bb5\n    var mid = (left + right) / 2;           // \u8ba1\u7b97\u4e2d\u70b9\n    try mergeSort(nums, left, mid);         // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\n    try mergeSort(nums, mid + 1, right);    // \u9012\u5f52\u53f3\u5b50\u6570\u7ec4\n    // \u5408\u5e76\u9636\u6bb5\n    try merge(nums, left, mid, right);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/merge_sort/#1162","title":"11.6.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\u4e3a \\(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":"

    \u5bf9\u4e8e\u94fe\u8868\uff0c\u5f52\u5e76\u6392\u5e8f\u76f8\u8f83\u4e8e\u5176\u4ed6\u6392\u5e8f\u7b97\u6cd5\u5177\u6709\u663e\u8457\u4f18\u52bf\uff0c\u53ef\u4ee5\u5c06\u94fe\u8868\u6392\u5e8f\u4efb\u52a1\u7684\u7a7a\u95f4\u590d\u6742\u5ea6\u4f18\u5316\u81f3 \\(O(1)\\) \u3002

    • \u5212\u5206\u9636\u6bb5\uff1a\u53ef\u4ee5\u4f7f\u7528\u201c\u8fed\u4ee3\u201d\u66ff\u4ee3\u201c\u9012\u5f52\u201d\u6765\u5b9e\u73b0\u94fe\u8868\u5212\u5206\u5de5\u4f5c\uff0c\u4ece\u800c\u7701\u53bb\u9012\u5f52\u4f7f\u7528\u7684\u6808\u5e27\u7a7a\u95f4\u3002
    • \u5408\u5e76\u9636\u6bb5\uff1a\u5728\u94fe\u8868\u4e2d\uff0c\u8282\u70b9\u589e\u5220\u64cd\u4f5c\u4ec5\u9700\u6539\u53d8\u5f15\u7528\uff08\u6307\u9488\uff09\u5373\u53ef\u5b9e\u73b0\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\u987b\u521b\u5efa\u989d\u5916\u94fe\u8868\u3002

    \u5177\u4f53\u5b9e\u73b0\u7ec6\u8282\u6bd4\u8f83\u590d\u6742\uff0c\u6709\u5174\u8da3\u7684\u8bfb\u8005\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\u7b56\u7565\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\u201c\u54e8\u5175\u5212\u5206\u201d\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\u5982\u56fe 11-8 \u6240\u793a\u3002

    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\u3002
    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\u3002
    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\u3002
    <1><2><3><4><5><6><7><8><9>

    \u56fe 11-8 \u00a0 \u54e8\u5175\u5212\u5206\u6b65\u9aa4

    \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

    \u5feb\u901f\u6392\u5e8f\u7684\u5206\u6cbb\u7b56\u7565

    \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

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig quick_sort.py
    def partition(self, nums: list[int], left: int, right: int) -> int:\n    \"\"\"\u54e8\u5175\u5212\u5206\"\"\"\n    # \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    i, j = left, right\n    while i < j:\n        while i < j and nums[j] >= nums[left]:\n            j -= 1  # \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while i < j and nums[i] <= nums[left]:\n            i += 1  # \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        # \u5143\u7d20\u4ea4\u6362\n        nums[i], nums[j] = nums[j], nums[i]\n    # \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n
    quick_sort.cpp
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(vector<int> &nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nint partition(vector<int> &nums, int left, int right) {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.java
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid swap(int[] nums, int i, int j) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nint partition(int[] nums, int left, int right) {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cs
    /* \u5143\u7d20\u4ea4\u6362 */\nvoid Swap(int[] nums, int i, int j) {\n    (nums[j], nums[i]) = (nums[i], nums[j]);\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nint Partition(int[] nums, int left, int right) {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.go
    /* \u54e8\u5175\u5212\u5206 */\nfunc (q *quickSort) partition(nums []int, left, right int) int {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    i, j := left, right\n    for i < j {\n        for i < j && nums[j] >= nums[left] {\n            j-- // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        for i < j && nums[i] <= nums[left] {\n            i++ // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        // \u5143\u7d20\u4ea4\u6362\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    nums[i], nums[left] = nums[left], nums[i]\n    return i // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.swift
    /* \u54e8\u5175\u5212\u5206 */\nfunc partition(nums: inout [Int], left: Int, right: Int) -> Int {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    var i = left\n    var j = right\n    while i < j {\n        while i < j, nums[j] >= nums[left] {\n            j -= 1 // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while i < j, nums[i] <= nums[left] {\n            i += 1 // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        nums.swapAt(i, j) // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    nums.swapAt(i, left) // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return i // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.js
    /* \u5143\u7d20\u4ea4\u6362 */\nswap(nums, i, j) {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\npartition(nums, left, right) {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let i = left,\n        j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        // \u5143\u7d20\u4ea4\u6362\n        this.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    this.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return 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 {\n    let tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\npartition(nums: number[], left: number, right: number): number {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let i = left,\n        j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        // \u5143\u7d20\u4ea4\u6362\n        this.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    this.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return 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) {\n  int tmp = nums[i];\n  nums[i] = nums[j];\n  nums[j] = tmp;\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nint _partition(List<int> nums, int left, int right) {\n  // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n  int i = left, j = right;\n  while (i < j) {\n    while (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n    while (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\n  return i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.rs
    /* \u54e8\u5175\u5212\u5206 */\nfn partition(nums: &mut [i32], left: usize, right: usize) -> usize {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let (mut i, mut j) = (left, right);\n    while i < j {\n        while i < j && nums[j] >= nums[left] {\n            j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while i < j && nums[i] <= nums[left] {\n            i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        nums.swap(i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    nums.swap(i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    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) {\n    int tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n            j--;\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n            i++;\n        }\n        // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n        swap(nums, i, j);\n    }\n    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    swap(nums, i, left);\n    // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n    return i;\n}\n
    quick_sort.kt
    /* \u5143\u7d20\u4ea4\u6362 */\nfun swap(nums: IntArray, i: Int, j: Int) {\n    nums[i] = nums[j].also { nums[j] = nums[i] }\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    var i = left\n    var j = right\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--           // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i              // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.rb
    [class]{QuickSort}-[func]{partition}\n
    quick_sort.zig
    // \u5143\u7d20\u4ea4\u6362\nfn swap(nums: []i32, i: usize, j: usize) void {\n    var tmp = nums[i];\n    nums[i] = nums[j];\n    nums[j] = tmp;\n}\n\n// \u54e8\u5175\u5212\u5206\nfn partition(nums: []i32, left: usize, right: usize) usize {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    var i = left;\n    var j = right;\n    while (i < j) {\n        while (i < j and nums[j] >= nums[left]) j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j and nums[i] <= nums[left]) i += 1; // \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\n    return i;               // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/quick_sort/#1151","title":"11.5.1 \u00a0 \u7b97\u6cd5\u6d41\u7a0b","text":"

    \u5feb\u901f\u6392\u5e8f\u7684\u6574\u4f53\u6d41\u7a0b\u5982\u56fe 11-9 \u6240\u793a\u3002

    1. \u9996\u5148\uff0c\u5bf9\u539f\u6570\u7ec4\u6267\u884c\u4e00\u6b21\u201c\u54e8\u5175\u5212\u5206\u201d\uff0c\u5f97\u5230\u672a\u6392\u5e8f\u7684\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u3002
    2. \u7136\u540e\uff0c\u5bf9\u5de6\u5b50\u6570\u7ec4\u548c\u53f3\u5b50\u6570\u7ec4\u5206\u522b\u9012\u5f52\u6267\u884c\u201c\u54e8\u5175\u5212\u5206\u201d\u3002
    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\u3002

    \u56fe 11-9 \u00a0 \u5feb\u901f\u6392\u5e8f\u6d41\u7a0b

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig quick_sort.py
    def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"\u5feb\u901f\u6392\u5e8f\"\"\"\n    # \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    if left >= right:\n        return\n    # \u54e8\u5175\u5212\u5206\n    pivot = self.partition(nums, left, right)\n    # \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    self.quick_sort(nums, left, pivot - 1)\n    self.quick_sort(nums, pivot + 1, right)\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\n    if (left >= right)\n        return;\n    // \u54e8\u5175\u5212\u5206\n    int pivot = partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n
    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\n    if (left >= right)\n        return;\n    // \u54e8\u5175\u5212\u5206\n    int pivot = partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1);\n    quickSort(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\n    if (left >= right)\n        return;\n    // \u54e8\u5175\u5212\u5206\n    int pivot = Partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    QuickSort(nums, left, pivot - 1);\n    QuickSort(nums, pivot + 1, right);\n}\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\n    if left >= right {\n        return\n    }\n    // \u54e8\u5175\u5212\u5206\n    pivot := q.partition(nums, left, right)\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    q.quickSort(nums, left, pivot-1)\n    q.quickSort(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\n    if left >= right {\n        return\n    }\n    // \u54e8\u5175\u5212\u5206\n    let pivot = partition(nums: &nums, left: left, right: right)\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums: &nums, left: left, right: pivot - 1)\n    quickSort(nums: &nums, left: pivot + 1, right: 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\n    if (left >= right) return;\n    // \u54e8\u5175\u5212\u5206\n    const pivot = this.partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    this.quickSort(nums, left, pivot - 1);\n    this.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\n    if (left >= right) {\n        return;\n    }\n    // \u54e8\u5175\u5212\u5206\n    const pivot = this.partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    this.quickSort(nums, left, pivot - 1);\n    this.quickSort(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\n  if (left >= right) return;\n  // \u54e8\u5175\u5212\u5206\n  int pivot = _partition(nums, left, right);\n  // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n  quickSort(nums, left, pivot - 1);\n  quickSort(nums, pivot + 1, right);\n}\n
    quick_sort.rs
    /* \u5feb\u901f\u6392\u5e8f */\npub fn quick_sort(left: i32, right: i32, nums: &mut [i32]) {\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    if left >= right {\n        return;\n    }\n    // \u54e8\u5175\u5212\u5206\n    let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    Self::quick_sort(left, pivot - 1, nums);\n    Self::quick_sort(pivot + 1, right, nums);\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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n            j--;\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n            i++;\n        }\n        // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n        swap(nums, i, j);\n    }\n    // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    swap(nums, i, left);\n    // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n    return i;\n}\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\n    if (left >= right) {\n        return;\n    }\n    // \u54e8\u5175\u5212\u5206\n    int pivot = partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n
    quick_sort.kt
    /* \u5feb\u901f\u6392\u5e8f */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    if (left >= right) return\n    // \u54e8\u5175\u5212\u5206\n    val pivot = partition(nums, left, right)\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n
    quick_sort.rb
    [class]{QuickSort}-[func]{quick_sort}\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\n    if (left >= right) return;\n    // \u54e8\u5175\u5212\u5206\n    var pivot = partition(nums, left, right);\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1);\n    quickSort(nums, pivot + 1, right);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/quick_sort/#1152","title":"11.5.2 \u00a0 \u7b97\u6cd5\u7279\u6027","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(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\\) \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\u4e3a \\(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\u901f\u6392\u5e8f\u4e3a\u4ec0\u4e48\u5feb","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\u201c\u5f52\u5e76\u6392\u5e8f\u201d\u548c\u201c\u5806\u6392\u5e8f\u201d\u76f8\u540c\uff0c\u4f46\u901a\u5e38\u5feb\u901f\u6392\u5e8f\u7684\u6548\u7387\u66f4\u9ad8\uff0c\u4e3b\u8981\u6709\u4ee5\u4e0b\u539f\u56e0\u3002

    • \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\u201c\u5806\u6392\u5e8f\u201d\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\u5c0f\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\u201c\u63d2\u5165\u6392\u5e8f\u201d\u6bd4\u201c\u5192\u6ce1\u6392\u5e8f\u201d\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\u90fd\u6709\u4e00\u4e2a\u5b50\u6570\u7ec4\u7684\u957f\u5ea6\u4e3a \\(0\\) \uff0c\u5206\u6cbb\u7b56\u7565\u5931\u6548\uff0c\u5feb\u901f\u6392\u5e8f\u9000\u5316\u4e3a\u201c\u5192\u6ce1\u6392\u5e8f\u201d\u7684\u8fd1\u4f3c\u5f62\u5f0f\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

    \u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig quick_sort.py
    def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:\n    \"\"\"\u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\"\"\"\n    l, m, r = nums[left], nums[mid], nums[right]\n    if (l <= m <= r) or (r <= m <= l):\n        return mid  # m \u5728 l \u548c r \u4e4b\u95f4\n    if (m <= l <= r) or (r <= l <= m):\n        return left  # l \u5728 m \u548c r \u4e4b\u95f4\n    return right\n\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] \u4e3a\u57fa\u51c6\u6570\n    med = self.median_three(nums, left, (left + right) // 2, right)\n    # \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    nums[left], nums[med] = nums[med], nums[left]\n    # \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    i, j = left, right\n    while i < j:\n        while i < j and nums[j] >= nums[left]:\n            j -= 1  # \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while i < j and nums[i] <= nums[left]:\n            i += 1  # \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        # \u5143\u7d20\u4ea4\u6362\n        nums[i], nums[j] = nums[j], nums[i]\n    # \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    nums[i], nums[left] = nums[left], nums[i]\n    return i  # \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n
    quick_sort.cpp
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(vector<int> &nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return right;\n}\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\n    int 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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.java
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint medianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return right;\n}\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\n    int 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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.cs
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint MedianThree(int[] nums, int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return right;\n}\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\n    int 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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--;          // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;             // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.go
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfunc (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {\n    l, m, r := nums[left], nums[mid], nums[right]\n    if (l <= m && m <= r) || (r <= m && m <= l) {\n        return mid // m \u5728 l \u548c r \u4e4b\u95f4\n    }\n    if (m <= l && l <= r) || (r <= l && l <= m) {\n        return left // l \u5728 m \u548c r \u4e4b\u95f4\n    }\n    return right\n}\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] \u4e3a\u57fa\u51c6\u6570\n    med := q.medianThree(nums, left, (left+right)/2, right)\n    // \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    nums[left], nums[med] = nums[med], nums[left]\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    i, j := left, right\n    for i < j {\n        for i < j && nums[j] >= nums[left] {\n            j-- //\u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        for i < j && nums[i] <= nums[left] {\n            i++ //\u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        //\u5143\u7d20\u4ea4\u6362\n        nums[i], nums[j] = nums[j], nums[i]\n    }\n    //\u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    nums[i], nums[left] = nums[left], nums[i]\n    return i //\u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.swift
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfunc medianThree(nums: [Int], left: Int, mid: Int, right: Int) -> Int {\n    let l = nums[left]\n    let m = nums[mid]\n    let r = nums[right]\n    if (l <= m && m <= r) || (r <= m && m <= l) {\n        return mid // m \u5728 l \u548c r \u4e4b\u95f4\n    }\n    if (m <= l && l <= r) || (r <= l && l <= m) {\n        return left // l \u5728 m \u548c r \u4e4b\u95f4\n    }\n    return 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\n    let 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\n    nums.swapAt(left, med)\n    return partition(nums: &nums, left: left, right: right)\n}\n
    quick_sort.js
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nmedianThree(nums, left, mid, right) {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;\n    // l \u5728 m \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m)) return left;\n    return right;\n}\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\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    this.swap(nums, left, med);\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let i = left,\n        j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left]) i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        this.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    this.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.ts
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nmedianThree(\n    nums: number[],\n    left: number,\n    mid: number,\n    right: number\n): number {\n    let l = nums[left],\n        m = nums[mid],\n        r = nums[right];\n    // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;\n    // l \u5728 m \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m)) return left;\n    return 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\n    let med = this.medianThree(\n        nums,\n        left,\n        Math.floor((left + right) / 2),\n        right\n    );\n    // \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    this.swap(nums, left, med);\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let i = left,\n        j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left]) {\n            j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while (i < j && nums[i] <= nums[left]) {\n            i++; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        this.swap(nums, i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    this.swap(nums, i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    return i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.dart
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nint _medianThree(List<int> nums, int left, int mid, int right) {\n  int l = nums[left], m = nums[mid], r = nums[right];\n  if ((l <= m && m <= r) || (r <= m && m <= l))\n    return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n  if ((m <= l && l <= r) || (r <= l && l <= m))\n    return left; // l \u5728 m \u548c r \u4e4b\u95f4\n  return right;\n}\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\n  int 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] \u4e3a\u57fa\u51c6\u6570\n  int i = left, j = right;\n  while (i < j) {\n    while (i < j && nums[j] >= nums[left]) j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n    while (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\n  return i; // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.rs
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfn median_three(nums: &mut [i32], left: usize, mid: usize, right: usize) -> usize {\n    let (l, m, r) = (nums[left], nums[mid], nums[right]);\n    if (l <= m && m <= r) || (r <= m && m <= l) {\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    }\n    if (m <= l && l <= r) || (r <= l && l <= m) {\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    }\n    right\n}\n\n/* \u54e8\u5175\u5212\u5206\uff08\u4e09\u6570\u53d6\u4e2d\u503c\uff09 */\nfn partition(nums: &mut [i32], left: usize, right: usize) -> usize {\n    // \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\n    let med = Self::median_three(nums, left, (left + right) / 2, right);\n    // \u5c06\u4e2d\u4f4d\u6570\u4ea4\u6362\u81f3\u6570\u7ec4\u6700\u5de6\u7aef\n    nums.swap(left, med);\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    let (mut i, mut j) = (left, right);\n    while i < j {\n        while i < j && nums[j] >= nums[left] {\n            j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        while i < j && nums[i] <= nums[left] {\n            i += 1; // \u4ece\u5de6\u5411\u53f3\u627e\u9996\u4e2a\u5927\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        }\n        nums.swap(i, j); // \u4ea4\u6362\u8fd9\u4e24\u4e2a\u5143\u7d20\n    }\n    nums.swap(i, left); // \u5c06\u57fa\u51c6\u6570\u4ea4\u6362\u81f3\u4e24\u5b50\u6570\u7ec4\u7684\u5206\u754c\u7ebf\n    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\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nint medianThree(int nums[], int left, int mid, int right) {\n    int l = nums[left], m = nums[mid], r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return right;\n}\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\n    int 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] \u4e3a\u57fa\u51c6\u6570\n    int i = left, j = right;\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i;            // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.kt
    /* \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570 */\nfun medianThree(nums: IntArray, left: Int, mid: Int, right: Int): Int {\n    val l = nums[left]\n    val m = nums[mid]\n    val r = nums[right]\n    if ((m in l..r) || (m in r..l))\n        return mid  // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((l in m..r) || (l in r..m))\n        return left // l \u5728 m \u548c r \u4e4b\u95f4\n    return right\n}\n\n/* \u54e8\u5175\u5212\u5206 */\nfun partition(nums: IntArray, left: Int, right: Int): Int {\n    // \u4ee5 nums[left] \u4e3a\u57fa\u51c6\u6570\n    var i = left\n    var j = right\n    while (i < j) {\n        while (i < j && nums[j] >= nums[left])\n            j--           // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j && nums[i] <= nums[left])\n            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\n    return i              // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    quick_sort.rb
    [class]{QuickSortMedian}-[func]{median_three}\n\n[class]{QuickSortMedian}-[func]{partition}\n
    quick_sort.zig
    // \u9009\u53d6\u4e09\u4e2a\u5019\u9009\u5143\u7d20\u7684\u4e2d\u4f4d\u6570\nfn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {\n    var l = nums[left];\n    var m = nums[mid];\n    var r = nums[right];\n    if ((l <= m && m <= r) || (r <= m && m <= l))\n        return mid; // m \u5728 l \u548c r \u4e4b\u95f4\n    if ((m <= l && l <= r) || (r <= l && l <= m))\n        return left; // l \u5728 m \u548c r \u4e4b\u95f4\n    return 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\n    var 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] \u4e3a\u57fa\u51c6\u6570\n    var i = left;\n    var j = right;\n    while (i < j) {\n        while (i < j and nums[j] >= nums[left]) j -= 1; // \u4ece\u53f3\u5411\u5de6\u627e\u9996\u4e2a\u5c0f\u4e8e\u57fa\u51c6\u6570\u7684\u5143\u7d20\n        while (i < j and nums[i] <= nums[left]) i += 1; // \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\n    return i;               // \u8fd4\u56de\u57fa\u51c6\u6570\u7684\u7d22\u5f15\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\u6709\u5e8f\u7684\u8f93\u5165\u6570\u7ec4\u4e3a\u4f8b\uff0c\u8bbe\u9012\u5f52\u4e2d\u7684\u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a \\(m\\) \uff0c\u6bcf\u8f6e\u54e8\u5175\u5212\u5206\u64cd\u4f5c\u90fd\u5c06\u4ea7\u751f\u957f\u5ea6\u4e3a \\(0\\) \u7684\u5de6\u5b50\u6570\u7ec4\u548c\u957f\u5ea6\u4e3a \\(m - 1\\) \u7684\u53f3\u5b50\u6570\u7ec4\uff0c\u8fd9\u610f\u5473\u7740\u6bcf\u4e00\u5c42\u9012\u5f52\u8c03\u7528\u51cf\u5c11\u7684\u95ee\u9898\u89c4\u6a21\u975e\u5e38\u5c0f\uff08\u53ea\u51cf\u5c11\u4e00\u4e2a\u5143\u7d20\uff09\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 \\(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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig quick_sort.py
    def quick_sort(self, nums: list[int], left: int, right: int):\n    \"\"\"\u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\"\"\"\n    # \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\n    while left < right:\n        # \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        pivot = self.partition(nums, left, right)\n        # \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if pivot - left < right - pivot:\n            self.quick_sort(nums, left, pivot - 1)  # \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1  # \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        else:\n            self.quick_sort(nums, pivot + 1, right)  # \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1  # \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        int pivot = partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1;                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1;                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n        }\n    }\n}\n
    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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        int pivot = partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        int pivot = Partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            QuickSort(nums, left, pivot - 1);  // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1;  // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            QuickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n        }\n    }\n}\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\n    for left < right {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        pivot := q.partition(nums, left, right)\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if pivot-left < right-pivot {\n            q.quickSort(nums, left, pivot-1) // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1                 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            q.quickSort(nums, pivot+1, right) // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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) {\n    var left = left\n    var right = right\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\n    while left < right {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        let pivot = partition(nums: &nums, left: left, right: right)\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left) < (right - pivot) {\n            quickSortTailCall(nums: &nums, left: left, right: pivot - 1) // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1 // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums: &nums, left: pivot + 1, right: right) // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        let pivot = this.partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        let pivot = this.partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            this.quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            this.quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n  while (left < right) {\n    // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n    int pivot = _partition(nums, left, right);\n    // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n    if (pivot - left < right - pivot) {\n      quickSort(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n      left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n    } else {\n      quickSort(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n      right = pivot - 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n    }\n  }\n}\n
    quick_sort.rs
    /* \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09 */\npub fn quick_sort(mut left: i32, mut right: i32, nums: &mut [i32]) {\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\n    while left < right {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        let pivot = Self::partition(nums, left as usize, right as usize) as i32;\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if pivot - left < right - pivot {\n            Self::quick_sort(left, pivot - 1, nums); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1; // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            Self::quick_sort(pivot + 1, right, nums); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = 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\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        int pivot = partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            quickSortTailCall(nums, left, pivot - 1); // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1;                         // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSortTailCall(nums, pivot + 1, right); // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1;                         // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n        }\n    }\n}\n
    quick_sort.kt
    /* \u5feb\u901f\u6392\u5e8f */\nfun quickSort(nums: IntArray, left: Int, right: Int) {\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    if (left >= right) return\n    // \u54e8\u5175\u5212\u5206\n    val pivot = partition(nums, left, right)\n    // \u9012\u5f52\u5de6\u5b50\u6570\u7ec4\u3001\u53f3\u5b50\u6570\u7ec4\n    quickSort(nums, left, pivot - 1)\n    quickSort(nums, pivot + 1, right)\n}\n
    quick_sort.rb
    [class]{QuickSortTailCall}-[func]{quick_sort}\n
    quick_sort.zig
    // \u5feb\u901f\u6392\u5e8f\uff08\u5c3e\u9012\u5f52\u4f18\u5316\uff09\nfn quickSort(nums: []i32, left_: usize, right_: usize) void {\n    var left = left_;\n    var right = right_;\n    // \u5b50\u6570\u7ec4\u957f\u5ea6\u4e3a 1 \u65f6\u7ec8\u6b62\u9012\u5f52\n    while (left < right) {\n        // \u54e8\u5175\u5212\u5206\u64cd\u4f5c\n        var pivot = partition(nums, left, right);\n        // \u5bf9\u4e24\u4e2a\u5b50\u6570\u7ec4\u4e2d\u8f83\u77ed\u7684\u90a3\u4e2a\u6267\u884c\u5feb\u901f\u6392\u5e8f\n        if (pivot - left < right - pivot) {\n            quickSort(nums, left, pivot - 1);   // \u9012\u5f52\u6392\u5e8f\u5de6\u5b50\u6570\u7ec4\n            left = pivot + 1;                   // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [pivot + 1, right]\n        } else {\n            quickSort(nums, pivot + 1, right);  // \u9012\u5f52\u6392\u5e8f\u53f3\u5b50\u6570\u7ec4\n            right = pivot - 1;                  // \u5269\u4f59\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [left, pivot - 1]\n        }\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_sorting/radix_sort/","title":"11.10 \u00a0 \u57fa\u6570\u6392\u5e8f","text":"

    \u4e0a\u4e00\u8282\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\u6d41\u7a0b\u5982\u56fe 11-18 \u6240\u793a\u3002

    1. \u521d\u59cb\u5316\u4f4d\u6570 \\(k = 1\\) \u3002
    2. \u5bf9\u5b66\u53f7\u7684\u7b2c \\(k\\) \u4f4d\u6267\u884c\u201c\u8ba1\u6570\u6392\u5e8f\u201d\u3002\u5b8c\u6210\u540e\uff0c\u6570\u636e\u4f1a\u6839\u636e\u7b2c \\(k\\) \u4f4d\u4ece\u5c0f\u5230\u5927\u6392\u5e8f\u3002
    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\u3002

    \u56fe 11-18 \u00a0 \u57fa\u6570\u6392\u5e8f\u7b97\u6cd5\u6d41\u7a0b

    \u4e0b\u9762\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 \\: d\\) \u8868\u793a\u5bf9 \\(d\\) \u53d6\u6a21\uff08\u53d6\u4f59\uff09\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    return (num // exp) % 10\n\ndef counting_sort_digit(nums: list[int], exp: int):\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\u6570\u7ec4\n    counter = [0] * 10\n    n = len(nums)\n    # \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for i in range(n):\n        d = digit(nums[i], exp)  # \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for i in range(1, 10):\n        counter[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\n    res = [0] * n\n    for i in range(n - 1, -1, -1):\n        d = digit(nums[i], exp)\n        j = counter[d] - 1  # \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]  # \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d] -= 1  # \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    # \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for i in range(n):\n        nums[i] = res[i]\n\ndef radix_sort(nums: list[int]):\n    \"\"\"\u57fa\u6570\u6392\u5e8f\"\"\"\n    # \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\n    m = max(nums)\n    # \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    exp = 1\n    while 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)\n        counting_sort_digit(nums, exp)\n        exp *= 10\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\n    return (num / exp) % 10;\n}\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\u6570\u7ec4\n    vector<int> counter(10, 0);\n    int n = nums.size();\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (int i = 0; i < n; i++) {\n        int d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (int i = 1; i < 10; i++) {\n        counter[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\n    vector<int> res(n, 0);\n    for (int i = n - 1; i >= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (int i = 0; i < n; i++)\n        nums[i] = res[i];\n}\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\n    int m = *max_element(nums.begin(), nums.end());\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(nums, exp);\n}\n
    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\n    return (num / exp) % 10;\n}\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\u6570\u7ec4\n    int[] counter = new int[10];\n    int n = nums.length;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (int i = 0; i < n; i++) {\n        int d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (int i = 1; i < 10; i++) {\n        counter[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\n    int[] res = new int[n];\n    for (int i = n - 1; i >= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (int i = 0; i < n; i++)\n        nums[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\n    int m = Integer.MIN_VALUE;\n    for (int num : nums)\n        if (num > m)\n            m = num;\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(nums, 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\n    return (num / exp) % 10;\n}\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\u6570\u7ec4\n    int[] counter = new int[10];\n    int n = nums.Length;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (int i = 0; i < n; i++) {\n        int d = Digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (int i = 1; i < 10; i++) {\n        counter[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\n    int[] res = new int[n];\n    for (int i = n - 1; i >= 0; i--) {\n        int d = Digit(nums[i], exp);\n        int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (int i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\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\n    int m = int.MinValue;\n    foreach (int num in nums) {\n        if (num > m) m = num;\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        CountingSortDigit(nums, exp);\n    }\n}\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\n    return (num / exp) % 10\n}\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\u6570\u7ec4\n    counter := make([]int, 10)\n    n := len(nums)\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for i := 0; i < n; i++ {\n        d := digit(nums[i], exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for i := 1; i < 10; i++ {\n        counter[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\n    res := make([]int, n)\n    for i := n - 1; i >= 0; i-- {\n        d := digit(nums[i], exp)\n        j := counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]    // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--        // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for i := 0; i < n; i++ {\n        nums[i] = res[i]\n    }\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\n    max := math.MinInt\n    for _, num := range nums {\n        if num > max {\n            max = num\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for 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)\n        countingSortDigit(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\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\u6570\u7ec4\n    var counter = Array(repeating: 0, count: 10)\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for i in nums.indices {\n        let d = digit(num: nums[i], exp: exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for i in 1 ..< 10 {\n        counter[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\n    var res = Array(repeating: 0, count: nums.count)\n    for i in nums.indices.reversed() {\n        let d = digit(num: nums[i], exp: exp)\n        let j = counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i] // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d] -= 1 // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for i in nums.indices {\n        nums[i] = res[i]\n    }\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\n    var m = Int.min\n    for num in nums {\n        if num > m {\n            m = num\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for 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)\n        countingSortDigit(nums: &nums, exp: 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\n    return Math.floor(num / exp) % 10;\n}\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\u6570\u7ec4\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (let i = 0; i < n; i++) {\n        const d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (let i = 1; i < 10; i++) {\n        counter[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\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i >= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (let i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\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\n    let m = Number.MIN_VALUE;\n    for (const num of nums) {\n        if (num > m) {\n            m = num;\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(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\n    return Math.floor(num / exp) % 10;\n}\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\u6570\u7ec4\n    const counter = new Array(10).fill(0);\n    const n = nums.length;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (let i = 0; i < n; i++) {\n        const d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (let i = 1; i < 10; i++) {\n        counter[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\n    const res = new Array(n).fill(0);\n    for (let i = n - 1; i >= 0; i--) {\n        const d = digit(nums[i], exp);\n        const j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (let i = 0; i < n; i++) {\n        nums[i] = res[i];\n    }\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\n    let m = Number.MIN_VALUE;\n    for (const num of nums) {\n        if (num > m) {\n            m = num;\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(nums, exp);\n    }\n}\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\n  return (_num ~/ exp) % 10;\n}\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\u6570\u7ec4\n  List<int> counter = List<int>.filled(10, 0);\n  int n = nums.length;\n  // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n  for (int i = 0; i < n; i++) {\n    int d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n    counter[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\n  for (int i = 1; i < 10; i++) {\n    counter[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\n  List<int> res = List<int>.filled(n, 0);\n  for (int i = n - 1; i >= 0; i--) {\n    int d = digit(nums[i], exp);\n    int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n    res[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n    counter[d]--; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n  }\n  // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n  for (int i = 0; i < n; i++) nums[i] = res[i];\n}\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\n  int m = -1 << 63;\n  for (int _num in nums) if (_num > m) m = _num;\n  // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n  for (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)\n    countingSortDigit(nums, exp);\n}\n
    radix_sort.rs
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfn digit(num: i32, exp: i32) -> usize {\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    return ((num / exp) % 10) as usize;\n}\n\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfn counting_sort_digit(nums: &mut [i32], exp: i32) {\n    // \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\u6570\u7ec4\n    let mut counter = [0; 10];\n    let n = nums.len();\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for i in 0..n {\n        let d = digit(nums[i], exp); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for i in 1..10 {\n        counter[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\n    let mut res = vec![0; n];\n    for i in (0..n).rev() {\n        let d = digit(nums[i], exp);\n        let j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i]; // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d] -= 1; // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for i in 0..n {\n        nums[i] = res[i];\n    }\n}\n\n/* \u57fa\u6570\u6392\u5e8f */\nfn radix_sort(nums: &mut [i32]) {\n    // \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\n    let m = *nums.into_iter().max().unwrap();\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    let mut exp = 1;\n    while exp <= m {\n        counting_sort_digit(nums, exp);\n        exp *= 10;\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\n    return (num / exp) % 10;\n}\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\u6570\u7ec4\n    int *counter = (int *)malloc((sizeof(int) * 10));\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (int i = 0; i < size; i++) {\n        // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        int d = digit(nums[i], exp);\n        // \u7edf\u8ba1\u6570\u5b57 d \u7684\u51fa\u73b0\u6b21\u6570\n        counter[d]++;\n    }\n    // \u6c42\u524d\u7f00\u548c\uff0c\u5c06\u201c\u51fa\u73b0\u4e2a\u6570\u201d\u8f6c\u6362\u4e3a\u201c\u6570\u7ec4\u7d22\u5f15\u201d\n    for (int i = 1; i < 10; i++) {\n        counter[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\n    int *res = (int *)malloc(sizeof(int) * size);\n    for (int i = size - 1; i >= 0; i--) {\n        int d = digit(nums[i], exp);\n        int j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]--;           // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (int i = 0; i < size; i++) {\n        nums[i] = res[i];\n    }\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\n    int max = INT32_MIN;\n    for (size_t i = 0; i < size - 1; i++) {\n        if (nums[i] > max) {\n            max = nums[i];\n        }\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    for (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)\n        countingSortDigit(nums, size, exp);\n}\n
    radix_sort.kt
    /* \u83b7\u53d6\u5143\u7d20 num \u7684\u7b2c k \u4f4d\uff0c\u5176\u4e2d exp = 10^(k-1) */\nfun 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    return (num / exp) % 10\n}\n\n/* \u8ba1\u6570\u6392\u5e8f\uff08\u6839\u636e nums \u7b2c k \u4f4d\u6392\u5e8f\uff09 */\nfun countingSortDigit(nums: IntArray, exp: Int) {\n    // \u5341\u8fdb\u5236\u7684\u4f4d\u8303\u56f4\u4e3a 0~9 \uff0c\u56e0\u6b64\u9700\u8981\u957f\u5ea6\u4e3a 10 \u7684\u6876\u6570\u7ec4\n    val counter = IntArray(10)\n    val n = nums.size\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (i in 0..<n) {\n        val d = digit(nums[i], exp) // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    for (i in 1..9) {\n        counter[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\n    val res = IntArray(n)\n    for (i in n - 1 downTo 0) {\n        val d = digit(nums[i], exp)\n        val j = counter[d] - 1 // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i] // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d]-- // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    for (i in 0..<n) nums[i] = res[i]\n}\n\n/* \u57fa\u6570\u6392\u5e8f */\nfun radixSort(nums: IntArray) {\n    // \u83b7\u53d6\u6570\u7ec4\u7684\u6700\u5927\u5143\u7d20\uff0c\u7528\u4e8e\u5224\u65ad\u6700\u5927\u4f4d\u6570\n    var m = Int.MIN_VALUE\n    for (num in nums) if (num > m) m = num\n    var exp = 1\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    while (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)\n        countingSortDigit(nums, exp)\n        exp *= 10\n    }\n}\n
    radix_sort.rb
    [class]{}-[func]{digit}\n\n[class]{}-[func]{counting_sort_digit}\n\n[class]{}-[func]{radix_sort}\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\n    return @mod(@divFloor(num, exp), 10);\n}\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\u6570\u7ec4\n    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);\n    // defer mem_arena.deinit();\n    const mem_allocator = mem_arena.allocator();\n    var counter = try mem_allocator.alloc(usize, 10);\n    @memset(counter, 0);\n    var n = nums.len;\n    // \u7edf\u8ba1 0~9 \u5404\u6570\u5b57\u7684\u51fa\u73b0\u6b21\u6570\n    for (nums) |num| {\n        var d: u32 = @bitCast(digit(num, exp)); // \u83b7\u53d6 nums[i] \u7b2c k \u4f4d\uff0c\u8bb0\u4e3a d\n        counter[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\n    var i: usize = 1;\n    while (i < 10) : (i += 1) {\n        counter[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\n    var res = try mem_allocator.alloc(i32, n);\n    i = n - 1;\n    while (i >= 0) : (i -= 1) {\n        var d: u32 = @bitCast(digit(nums[i], exp));\n        var j = counter[d] - 1; // \u83b7\u53d6 d \u5728\u6570\u7ec4\u4e2d\u7684\u7d22\u5f15 j\n        res[j] = nums[i];       // \u5c06\u5f53\u524d\u5143\u7d20\u586b\u5165\u7d22\u5f15 j\n        counter[d] -= 1;        // \u5c06 d \u7684\u6570\u91cf\u51cf 1\n        if (i == 0) break;\n    }\n    // \u4f7f\u7528\u7ed3\u679c\u8986\u76d6\u539f\u6570\u7ec4 nums\n    i = 0;\n    while (i < n) : (i += 1) {\n        nums[i] = res[i];\n    }\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\n    var m: i32 = std.math.minInt(i32);\n    for (nums) |num| {\n        if (num > m) m = num;\n    }\n    // \u6309\u7167\u4ece\u4f4e\u4f4d\u5230\u9ad8\u4f4d\u7684\u987a\u5e8f\u904d\u5386\n    var exp: i32 = 1;\n    while (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)\n        try countingSortDigit(nums, exp);    \n    }\n} \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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\u56e0\u6b64\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\u4e3a \\(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\u4e3a \\(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\u5f53\u8ba1\u6570\u6392\u5e8f\u7a33\u5b9a\u65f6\uff0c\u57fa\u6570\u6392\u5e8f\u4e5f\u7a33\u5b9a\uff1b\u5f53\u8ba1\u6570\u6392\u5e8f\u4e0d\u7a33\u5b9a\u65f6\uff0c\u57fa\u6570\u6392\u5e8f\u65e0\u6cd5\u4fdd\u8bc1\u5f97\u5230\u6b63\u786e\u7684\u6392\u5e8f\u7ed3\u679c\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\u7b80\u5355\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\u56fe 11-2 \u6240\u793a\u3002

    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\u7684\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\u7684\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\u987b\u6392\u5e8f\uff0c\u56e0\u6b64\u6570\u7ec4\u6392\u5e8f\u5b8c\u6210\u3002
    <1><2><3><4><5><6><7><8><9><10><11>

    \u56fe 11-2 \u00a0 \u9009\u62e9\u6392\u5e8f\u6b65\u9aa4

    \u5728\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u7528 \\(k\\) \u6765\u8bb0\u5f55\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig selection_sort.py
    def selection_sort(nums: list[int]):\n    \"\"\"\u9009\u62e9\u6392\u5e8f\"\"\"\n    n = len(nums)\n    # \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for i in range(n - 1):\n        # \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        k = i\n        for j in range(i + 1, n):\n            if nums[j] < nums[k]:\n                k = 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\n        nums[i], nums[k] = nums[k], nums[i]\n
    selection_sort.cpp
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(vector<int> &nums) {\n    int n = nums.size();\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        int k = i;\n        for (int j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k])\n                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\n        swap(nums[i], nums[k]);\n    }\n}\n
    selection_sort.java
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(int[] nums) {\n    int n = nums.length;\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        int k = i;\n        for (int j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k])\n                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\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n
    selection_sort.cs
    /* \u9009\u62e9\u6392\u5e8f */\nvoid SelectionSort(int[] nums) {\n    int n = nums.Length;\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        int k = i;\n        for (int j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k])\n                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\n        (nums[k], nums[i]) = (nums[i], nums[k]);\n    }\n}\n
    selection_sort.go
    /* \u9009\u62e9\u6392\u5e8f */\nfunc selectionSort(nums []int) {\n    n := len(nums)\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for i := 0; i < n-1; i++ {\n        // \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        k := i\n        for j := i + 1; j < n; j++ {\n            if nums[j] < nums[k] {\n                // \u8bb0\u5f55\u6700\u5c0f\u5143\u7d20\u7684\u7d22\u5f15\n                k = j\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}\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]\n    for i in nums.indices.dropLast() {\n        // \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        var k = i\n        for j in nums.indices.dropFirst(i + 1) {\n            if nums[j] < nums[k] {\n                k = 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.swapAt(i, k)\n    }\n}\n
    selection_sort.js
    /* \u9009\u62e9\u6392\u5e8f */\nfunction selectionSort(nums) {\n    let n = nums.length;\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        let k = i;\n        for (let j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k]) {\n                k = 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 {\n    let n = nums.length;\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (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\n        let k = i;\n        for (let j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k]) {\n                k = 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.dart
    /* \u9009\u62e9\u6392\u5e8f */\nvoid selectionSort(List<int> nums) {\n  int n = nums.length;\n  // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n  for (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\n    int k = i;\n    for (int j = i + 1; j < n; j++) {\n      if (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\n    int temp = nums[i];\n    nums[i] = nums[k];\n    nums[k] = temp;\n  }\n}\n
    selection_sort.rs
    /* \u9009\u62e9\u6392\u5e8f */\nfn selection_sort(nums: &mut [i32]) {\n    if nums.is_empty() {\n        return;\n    }\n    let n = nums.len();\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for i in 0..n - 1 {\n        // \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        let mut k = i;\n        for j in i + 1..n {\n            if nums[j] < nums[k] {\n                k = 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.swap(i, k);\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]\n    for (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\n        int k = i;\n        for (int j = i + 1; j < n; j++) {\n            if (nums[j] < nums[k])\n                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\n        int temp = nums[i];\n        nums[i] = nums[k];\n        nums[k] = temp;\n    }\n}\n
    selection_sort.kt
    /* \u9009\u62e9\u6392\u5e8f */\nfun selectionSort(nums: IntArray) {\n    val n = nums.size\n    // \u5916\u5faa\u73af\uff1a\u672a\u6392\u5e8f\u533a\u95f4\u4e3a [i, n-1]\n    for (i in 0..<n - 1) {\n        var k = i\n        // \u5185\u5faa\u73af\uff1a\u627e\u5230\u672a\u6392\u5e8f\u533a\u95f4\u5185\u7684\u6700\u5c0f\u5143\u7d20\n        for (j in i + 1..<n) {\n            if (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\n        nums[i] = nums[k].also { nums[k] = nums[i] }\n    }\n}\n
    selection_sort.rb
    [class]{}-[func]{selection_sort}\n
    selection_sort.zig
    [class]{}-[func]{selectionSort}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\\)\u3001\\(n - 1\\)\u3001\\(\\dots\\)\u3001\\(3\\)\u3001\\(2\\) \u8f6e\u5185\u5faa\u73af\uff0c\u6c42\u548c\u4e3a \\(\\frac{(n - 1)(n + 2)}{2}\\) \u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(1)\\)\u3001\u539f\u5730\u6392\u5e8f\uff1a\u6307\u9488 \\(i\\) \u548c \\(j\\) \u4f7f\u7528\u5e38\u6570\u5927\u5c0f\u7684\u989d\u5916\u7a7a\u95f4\u3002
    • \u975e\u7a33\u5b9a\u6392\u5e8f\uff1a\u5982\u56fe 11-3 \u6240\u793a\uff0c\u5143\u7d20 nums[i] \u6709\u53ef\u80fd\u88ab\u4ea4\u6362\u81f3\u4e0e\u5176\u76f8\u7b49\u7684\u5143\u7d20\u7684\u53f3\u8fb9\uff0c\u5bfc\u81f4\u4e24\u8005\u7684\u76f8\u5bf9\u987a\u5e8f\u53d1\u751f\u6539\u53d8\u3002

    \u56fe 11-3 \u00a0 \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\u9ad8\u6548\u5730\u67e5\u627e\u3001\u5206\u6790\u548c\u5904\u7406\u3002

    \u5982\u56fe 11-1 \u6240\u793a\uff0c\u6392\u5e8f\u7b97\u6cd5\u4e2d\u7684\u6570\u636e\u7c7b\u578b\u53ef\u4ee5\u662f\u6574\u6570\u3001\u6d6e\u70b9\u6570\u3001\u5b57\u7b26\u6216\u5b57\u7b26\u4e32\u7b49\u3002\u6392\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

    \u56fe 11-1 \u00a0 \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\u65f6\u95f4\u590d\u6742\u5ea6\u4e2d\u7684\u5e38\u6570\u9879\u53d8\u5c0f\uff09\u3002\u5bf9\u4e8e\u5927\u6570\u636e\u91cf\u7684\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\u987b\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\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 \u5217\u548c\u7b2c 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\uff1a

    # \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\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\u65f6\u95f4\u590d\u6742\u5ea6\u3001\u6700\u5dee\u65f6\u95f4\u590d\u6742\u5ea6\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\u6bd4\u8f83\u8fd0\u7b97\u7b26\uff08\\(<\\)\u3001\\(=\\)\u3001\\(>\\)\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":""},{"location":"chapter_sorting/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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\u56e0\u6b64\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
    • \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
    • \u56fe 11-19 \u5bf9\u6bd4\u4e86\u4e3b\u6d41\u6392\u5e8f\u7b97\u6cd5\u7684\u6548\u7387\u3001\u7a33\u5b9a\u6027\u3001\u5c31\u5730\u6027\u548c\u81ea\u9002\u5e94\u6027\u7b49\u3002

    \u56fe 11-19 \u00a0 \u6392\u5e8f\u7b97\u6cd5\u5bf9\u6bd4

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

    Q\uff1a\u6392\u5e8f\u7b97\u6cd5\u7a33\u5b9a\u6027\u5728\u4ec0\u4e48\u60c5\u51b5\u4e0b\u662f\u5fc5\u9700\u7684\uff1f

    \u5728\u73b0\u5b9e\u4e2d\uff0c\u6211\u4eec\u6709\u53ef\u80fd\u57fa\u4e8e\u5bf9\u8c61\u7684\u67d0\u4e2a\u5c5e\u6027\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\uff1a\u5148\u6309\u7167\u59d3\u540d\u8fdb\u884c\u6392\u5e8f\uff0c\u5f97\u5230 (A, 180) (B, 185) (C, 170) (D, 170) \uff1b\u518d\u5bf9\u8eab\u9ad8\u8fdb\u884c\u6392\u5e8f\u3002\u7531\u4e8e\u6392\u5e8f\u7b97\u6cd5\u4e0d\u7a33\u5b9a\uff0c\u56e0\u6b64\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

    Q\uff1a\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\u5927\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

    Q\uff1a\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\u957f\u5ea6\u7684\u4e00\u534a\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\\)\u3001\\(n - 1\\)\u3001\\(\\dots\\)\u3001\\(2\\)\u3001\\(1\\) \uff0c\u9012\u5f52\u6df1\u5ea6\u4e3a \\(n\\) \u3002\u5c3e\u9012\u5f52\u4f18\u5316\u53ef\u4ee5\u907f\u514d\u8fd9\u79cd\u60c5\u51b5\u51fa\u73b0\u3002

    Q\uff1a\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\u5bf9\u4e8e\u8fd9\u79cd\u60c5\u51b5\uff0c\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

    Q\uff1a\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":"\u7b2c 5 \u7ae0 \u00a0 \u6808\u4e0e\u961f\u5217","text":"

    Abstract

    \u6808\u5982\u540c\u53e0\u732b\u732b\uff0c\u800c\u961f\u5217\u5c31\u50cf\u732b\u732b\u6392\u961f\u3002

    \u4e24\u8005\u5206\u522b\u4ee3\u8868\u5148\u5165\u540e\u51fa\u548c\u5148\u5165\u5148\u51fa\u7684\u903b\u8f91\u5173\u7cfb\u3002

    "},{"location":"chapter_stack_and_queue/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 5.1 \u00a0 \u6808
    • 5.2 \u00a0 \u961f\u5217
    • 5.3 \u00a0 \u53cc\u5411\u961f\u5217
    • 5.4 \u00a0 \u5c0f\u7ed3
    "},{"location":"chapter_stack_and_queue/deque/","title":"5.3 \u00a0 \u53cc\u5411\u961f\u5217","text":"

    \u5728\u961f\u5217\u4e2d\uff0c\u6211\u4eec\u4ec5\u80fd\u5220\u9664\u5934\u90e8\u5143\u7d20\u6216\u5728\u5c3e\u90e8\u6dfb\u52a0\u5143\u7d20\u3002\u5982\u56fe 5-7 \u6240\u793a\uff0c\u300c\u53cc\u5411\u961f\u5217 double-ended queue\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

    \u56fe 5-7 \u00a0 \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\u8868 5-3 \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

    \u8868 5-3 \u00a0 \u53cc\u5411\u961f\u5217\u64cd\u4f5c\u6548\u7387

    \u65b9\u6cd5\u540d \u63cf\u8ff0 \u65f6\u95f4\u590d\u6742\u5ea6 push_first() \u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u9996 \\(O(1)\\) push_last() \u5c06\u5143\u7d20\u6dfb\u52a0\u81f3\u961f\u5c3e \\(O(1)\\) pop_first() \u5220\u9664\u961f\u9996\u5143\u7d20 \\(O(1)\\) pop_last() \u5220\u9664\u961f\u5c3e\u5143\u7d20 \\(O(1)\\) peek_first() \u8bbf\u95ee\u961f\u9996\u5143\u7d20 \\(O(1)\\) peek_last() \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig deque.py
    from collections import deque\n\n# \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217\ndeque: deque[int] = deque()\n\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\n# \u8bbf\u95ee\u5143\u7d20\nfront: int = deque[0]  # \u961f\u9996\u5143\u7d20\nrear: int = deque[-1]  # \u961f\u5c3e\u5143\u7d20\n\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\n# \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\nsize: int = len(deque)\n\n# \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(deque) == 0\n
    deque.cpp
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\ndeque<int> deque;\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nint front = deque.front(); // \u961f\u9996\u5143\u7d20\nint back = deque.back();   // \u961f\u5c3e\u5143\u7d20\n\n/* \u5143\u7d20\u51fa\u961f */\ndeque.pop_front();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.pop_back();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.size();\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty = deque.empty();\n
    deque.java
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\nDeque<Integer> deque = new LinkedList<>();\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.peekFirst();  // \u961f\u9996\u5143\u7d20\nint peekLast = deque.peekLast();    // \u961f\u5c3e\u5143\u7d20\n\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\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.size();\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = deque.isEmpty();\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();\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.First.Value;  // \u961f\u9996\u5143\u7d20\nint peekLast = deque.Last.Value;    // \u961f\u5c3e\u5143\u7d20\n\n/* \u5143\u7d20\u51fa\u961f */\ndeque.RemoveFirst();  // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.RemoveLast();   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.Count;\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = deque.Count == 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\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nfront := deque.Front() // \u961f\u9996\u5143\u7d20\nrear := deque.Back()   // \u961f\u5c3e\u5143\u7d20\n\n/* \u5143\u7d20\u51fa\u961f */\ndeque.Remove(front)    // \u961f\u9996\u5143\u7d20\u51fa\u961f\ndeque.Remove(rear)     // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nsize := deque.Len()\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty := deque.Len() == 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\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nlet peekFirst = deque.first! // \u961f\u9996\u5143\u7d20\nlet peekLast = deque.last! // \u961f\u5c3e\u5143\u7d20\n\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\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = deque.count\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = deque.isEmpty\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\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);\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nconst peekFirst = deque[0];\nconst peekLast = deque[deque.length - 1];\n\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();\nconst popBack = deque.pop();\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = deque.length;\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst isEmpty = size === 0;\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\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);\n\n/* \u8bbf\u95ee\u5143\u7d20 */\nconst peekFirst: number = deque[0];\nconst peekLast: number = deque[deque.length - 1];\n\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;\nconst popBack: number = deque.pop() as number;\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nconst size: number = deque.length;\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst isEmpty: boolean = size === 0;\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\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nint peekFirst = deque.first; // \u961f\u9996\u5143\u7d20\nint peekLast = deque.last;   // \u961f\u5c3e\u5143\u7d20\n\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\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size = deque.length;\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = deque.isEmpty;\n
    deque.rs
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\nlet mut deque: VecDeque<u32> = VecDeque::new();\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nif let Some(front) = deque.front() { // \u961f\u9996\u5143\u7d20\n}\nif let Some(rear) = deque.back() {   // \u961f\u5c3e\u5143\u7d20\n}\n\n/* \u5143\u7d20\u51fa\u961f */\nif let Some(pop_front) = deque.pop_front() { // \u961f\u9996\u5143\u7d20\u51fa\u961f\n}\nif let Some(pop_rear) = deque.pop_back() {   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = deque.len();\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = deque.is_empty();\n
    deque.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u53cc\u5411\u961f\u5217\n
    deque.kt
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\nval deque = LinkedList<Int>()\n\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\n/* \u8bbf\u95ee\u5143\u7d20 */\nval peekFirst = deque.peekFirst() // \u961f\u9996\u5143\u7d20\nval peekLast = deque.peekLast()   // \u961f\u5c3e\u5143\u7d20\n\n/* \u5143\u7d20\u51fa\u961f */\nval popFirst = deque.pollFirst() // \u961f\u9996\u5143\u7d20\u51fa\u961f\nval popLast = deque.pollLast()   // \u961f\u5c3e\u5143\u7d20\u51fa\u961f\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nval size = deque.size\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = deque.isEmpty()\n
    deque.rb
    \n
    deque.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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":"1. \u00a0 \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\u201c\u53cc\u5411\u94fe\u8868\u201d\u4f5c\u4e3a\u53cc\u5411\u961f\u5217\u7684\u5e95\u5c42\u6570\u636e\u7ed3\u6784\u3002

    \u5982\u56fe 5-8 \u6240\u793a\uff0c\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

    LinkedListDequepush_last()push_first()pop_last()pop_first()

    \u56fe 5-8 \u00a0 \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u53cc\u5411\u961f\u5217\u7684\u5165\u961f\u51fa\u961f\u64cd\u4f5c

    \u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_deque.py
    class ListNode:\n    \"\"\"\u53cc\u5411\u94fe\u8868\u8282\u70b9\"\"\"\n\n    def __init__(self, val: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self.val: int = val\n        self.next: ListNode | None = None  # \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n        self.prev: ListNode | None = None  # \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\nclass LinkedListDeque:\n    \"\"\"\u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._front: ListNode | None = None  # \u5934\u8282\u70b9 front\n        self._rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\n        self._size: int = 0  # \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self.size() == 0\n\n    def push(self, num: int, is_front: bool):\n        \"\"\"\u5165\u961f\u64cd\u4f5c\"\"\"\n        node = ListNode(num)\n        # \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if self.is_empty():\n            self._front = self._rear = node\n        # \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        elif is_front:\n            # \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            self._front.prev = node\n            node.next = self._front\n            self._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\n            self._rear.next = node\n            node.prev = self._rear\n            self._rear = node  # \u66f4\u65b0\u5c3e\u8282\u70b9\n        self._size += 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n\n    def push_first(self, num: int):\n        \"\"\"\u961f\u9996\u5165\u961f\"\"\"\n        self.push(num, True)\n\n    def push_last(self, num: int):\n        \"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\n        self.push(num, False)\n\n    def pop(self, is_front: bool) -> int:\n        \"\"\"\u51fa\u961f\u64cd\u4f5c\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        # \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if is_front:\n            val: int = self._front.val  # \u6682\u5b58\u5934\u8282\u70b9\u503c\n            # \u5220\u9664\u5934\u8282\u70b9\n            fnext: ListNode | None = self._front.next\n            if fnext != None:\n                fnext.prev = None\n                self._front.next = None\n            self._front = fnext  # \u66f4\u65b0\u5934\u8282\u70b9\n        # \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else:\n            val: int = self._rear.val  # \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            # \u5220\u9664\u5c3e\u8282\u70b9\n            rprev: ListNode | None = self._rear.prev\n            if rprev != None:\n                rprev.next = None\n                self._rear.prev = None\n            self._rear = rprev  # \u66f4\u65b0\u5c3e\u8282\u70b9\n        self._size -= 1  # \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val\n\n    def pop_first(self) -> int:\n        \"\"\"\u961f\u9996\u51fa\u961f\"\"\"\n        return self.pop(True)\n\n    def pop_last(self) -> int:\n        \"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\n        return self.pop(False)\n\n    def peek_first(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._front.val\n\n    def peek_last(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._rear.val\n\n    def to_array(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\"\"\"\n        node = self._front\n        res = [0] * self.size()\n        for i in range(self.size()):\n            res[i] = node.val\n            node = node.next\n        return res\n
    linkedlist_deque.cpp
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nstruct DoublyListNode {\n    int val;              // \u8282\u70b9\u503c\n    DoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n    DoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\u6307\u9488\n    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {\n    }\n};\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n  private:\n    DoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize = 0;              // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    LinkedListDeque() : front(nullptr), rear(nullptr) {\n    }\n\n    /* \u6790\u6784\u65b9\u6cd5 */\n    ~LinkedListDeque() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        DoublyListNode *pre, *cur = front;\n        while (cur != nullptr) {\n            pre = cur;\n            cur = cur->next;\n            delete pre;\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    void push(int num, bool isFront) {\n        DoublyListNode *node = new DoublyListNode(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty())\n            front = rear = node;\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front->prev = node;\n            node->next = front;\n            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\n            rear->next = node;\n            node->prev = rear;\n            rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    int pop(bool isFront) {\n        if (isEmpty())\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        int val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front->val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            DoublyListNode *fNext = front->next;\n            if (fNext != nullptr) {\n                fNext->prev = nullptr;\n                front->next = nullptr;\n            }\n            delete front;\n            front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            val = rear->val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            DoublyListNode *rPrev = rear->prev;\n            if (rPrev != nullptr) {\n                rPrev->next = nullptr;\n                rear->prev = nullptr;\n            }\n            delete rear;\n            rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    int popFirst() {\n        return pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    int popLast() {\n        return pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return front->val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return rear->val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        DoublyListNode *node = front;\n        vector<int> res(size());\n        for (int i = 0; i < res.size(); i++) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_deque.java
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    int val; // \u8282\u70b9\u503c\n    ListNode next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    ListNode prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n    ListNode(int val) {\n        this.val = val;\n        prev = next = null;\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private int queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    public LinkedListDeque() {\n        front = rear = null;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    private void push(int num, boolean isFront) {\n        ListNode node = new ListNode(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty())\n            front = rear = node;\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front.prev = node;\n            node.next = front;\n            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\n            rear.next = node;\n            node.prev = rear;\n            rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void pushFirst(int num) {\n        push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    public void pushLast(int num) {\n        push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    private int pop(boolean isFront) {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        int val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            ListNode fNext = front.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front.next = null;\n            }\n            front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            val = rear.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            ListNode rPrev = rear.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear.prev = null;\n            }\n            rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int popFirst() {\n        return pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int popLast() {\n        return pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return rear.val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_deque.cs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode(int val) {\n    public int val = val;       // \u8282\u70b9\u503c\n    public ListNode? next = null; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    public ListNode? prev = null; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    ListNode? front, rear; // \u5934\u8282\u70b9 front, \u5c3e\u8282\u70b9 rear\n    int queSize = 0;      // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    public LinkedListDeque() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    void Push(int num, bool isFront) {\n        ListNode node = new(num);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (IsEmpty()) {\n            front = node;\n            rear = node;\n        }\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front!.prev = node;\n            node.next = front;\n            front = node; // \u66f4\u65b0\u5934\u8282\u70b9                           \n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            rear!.next = node;\n            node.prev = rear;\n            rear = node;  // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n\n        queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void PushFirst(int num) {\n        Push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    public void PushLast(int num) {\n        Push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    int? Pop(bool isFront) {\n        if (IsEmpty())\n            throw new Exception();\n        int? val;\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            val = front?.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            ListNode? fNext = front?.next;\n            if (fNext != null) {\n                fNext.prev = null;\n                front!.next = null;\n            }\n            front = fNext;   // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            val = rear?.val;  // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            ListNode? rPrev = rear?.prev;\n            if (rPrev != null) {\n                rPrev.next = null;\n                rear!.prev = null;\n            }\n            rear = rPrev;    // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n\n        queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int? PopFirst() {\n        return Pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int? PopLast() {\n        return Pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int? PeekFirst() {\n        if (IsEmpty())\n            throw new Exception();\n        return front?.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int? PeekLast() {\n        if (IsEmpty())\n            throw new Exception();\n        return rear?.val;\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int?[] ToArray() {\n        ListNode? node = front;\n        int?[] res = new int?[Size()];\n        for (int i = 0; i < res.Length; i++) {\n            res[i] = node?.val;\n            node = node?.next;\n        }\n\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u53cc\u7aef\u961f\u5217 */\nfunc newLinkedListDeque() *linkedListDeque {\n    return &linkedListDeque{\n        data: list.New(),\n    }\n}\n\n/* \u961f\u9996\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushFirst(value any) {\n    s.data.PushFront(value)\n}\n\n/* \u961f\u5c3e\u5143\u7d20\u5165\u961f */\nfunc (s *linkedListDeque) pushLast(value any) {\n    s.data.PushBack(value)\n}\n\n/* \u961f\u9996\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u961f\u5c3e\u5143\u7d20\u51fa\u961f */\nfunc (s *linkedListDeque) popLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListDeque) peekFirst() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (s *linkedListDeque) peekLast() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListDeque) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListDeque) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListDeque) toList() *list.List {\n    return s.data\n}\n
    linkedlist_deque.swift
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    var val: Int // \u8282\u70b9\u503c\n    var next: ListNode? // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    weak var prev: ListNode? // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n    init(val: Int) {\n        self.val = val\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private var front: ListNode? // \u5934\u8282\u70b9 front\n    private var rear: ListNode? // \u5c3e\u8282\u70b9 rear\n    private var _size: Int // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    private func push(num: Int, isFront: Bool) {\n        let node = ListNode(val: num)\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if isEmpty() {\n            front = node\n            rear = node\n        }\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        else if isFront {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front?.prev = node\n            node.next = front\n            front = node // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            rear?.next = node\n            node.prev = rear\n            rear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        _size += 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    func pushFirst(num: Int) {\n        push(num: num, isFront: true)\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    func pushLast(num: Int) {\n        push(num: num, isFront: false)\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    private func pop(isFront: Bool) -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        let val: Int\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if isFront {\n            val = front!.val // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            let fNext = front?.next\n            if fNext != nil {\n                fNext?.prev = nil\n                front?.next = nil\n            }\n            front = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            val = rear!.val // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            let rPrev = rear?.prev\n            if rPrev != nil {\n                rPrev?.next = nil\n                rear?.prev = nil\n            }\n            rear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        _size -= 1 // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return val\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    func popFirst() -> Int {\n        pop(isFront: true)\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    func popLast() -> Int {\n        pop(isFront: false)\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peekFirst() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return front!.val\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    func peekLast() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return rear!.val\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    func toArray() -> [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\n}\n
    linkedlist_deque.js
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    val; // \u8282\u70b9\u503c\n\n    constructor(val) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\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\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n        this.#queSize = 0;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\n    pushLast(val) {\n        const node = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            this.#rear.next = node;\n            node.prev = this.#rear;\n            this.#rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        this.#queSize++;\n    }\n\n    /* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\n    pushFirst(val) {\n        const node = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.#queSize === 0) {\n            this.#front = node;\n            this.#rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            this.#front.prev = node;\n            node.next = this.#front;\n            this.#front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        this.#queSize++;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\n    popLast() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5c3e\u8282\u70b9\n        let temp = this.#rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.#rear.prev = null;\n        }\n        this.#rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        this.#queSize--;\n        return value;\n    }\n\n    /* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\n    popFirst() {\n        if (this.#queSize === 0) {\n            return null;\n        }\n        const value = this.#front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5934\u8282\u70b9\n        let temp = this.#front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.#front.next = null;\n        }\n        this.#front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\n        this.#queSize--;\n        return value;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast() {\n        return this.#queSize === 0 ? null : this.#rear.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst() {\n        return this.#queSize === 0 ? null : this.#front.val;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u6253\u5370\u53cc\u5411\u961f\u5217 */\n    print() {\n        const arr = [];\n        let temp = this.#front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n
    linkedlist_deque.ts
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n    prev: ListNode; // \u524d\u9a71\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    next: ListNode; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528 (\u6307\u9488)\n    val: number; // \u8282\u70b9\u503c\n\n    constructor(val: number) {\n        this.val = val;\n        this.next = null;\n        this.prev = null;\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private front: ListNode; // \u5934\u8282\u70b9 front\n    private rear: ListNode; // \u5c3e\u8282\u70b9 rear\n    private queSize: number; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n        this.queSize = 0;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f\u64cd\u4f5c */\n    pushLast(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n            this.rear.next = node;\n            node.prev = this.rear;\n            this.rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        this.queSize++;\n    }\n\n    /* \u961f\u9996\u5165\u961f\u64cd\u4f5c */\n    pushFirst(val: number): void {\n        const node: ListNode = new ListNode(val);\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (this.queSize === 0) {\n            this.front = node;\n            this.rear = node;\n        } else {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            this.front.prev = node;\n            node.next = this.front;\n            this.front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n        }\n        this.queSize++;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c */\n    popLast(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.rear.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5c3e\u8282\u70b9\n        let temp: ListNode = this.rear.prev;\n        if (temp !== null) {\n            temp.next = null;\n            this.rear.prev = null;\n        }\n        this.rear = temp; // \u66f4\u65b0\u5c3e\u8282\u70b9\n        this.queSize--;\n        return value;\n    }\n\n    /* \u961f\u9996\u51fa\u961f\u64cd\u4f5c */\n    popFirst(): number {\n        if (this.queSize === 0) {\n            return null;\n        }\n        const value: number = this.front.val; // \u5b58\u50a8\u5c3e\u8282\u70b9\u503c\n        // \u5220\u9664\u5934\u8282\u70b9\n        let temp: ListNode = this.front.next;\n        if (temp !== null) {\n            temp.prev = null;\n            this.front.next = null;\n        }\n        this.front = temp; // \u66f4\u65b0\u5934\u8282\u70b9\n        this.queSize--;\n        return value;\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast(): number {\n        return this.queSize === 0 ? null : this.rear.val;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst(): number {\n        return this.queSize === 0 ? null : this.front.val;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u6253\u5370\u53cc\u5411\u961f\u5217 */\n    print(): void {\n        const arr: number[] = [];\n        let temp: ListNode = this.front;\n        while (temp !== null) {\n            arr.push(temp.val);\n            temp = temp.next;\n        }\n        console.log('[' + arr.join(', ') + ']');\n    }\n}\n
    linkedlist_deque.dart
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode {\n  int val; // \u8282\u70b9\u503c\n  ListNode? next; // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n  ListNode? prev; // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n\n  ListNode(this.val, {this.next, this.prev});\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u5bf9\u5217 */\nclass LinkedListDeque {\n  late ListNode? _front; // \u5934\u8282\u70b9 _front\n  late ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\n  int _queSize = 0; // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n  LinkedListDeque() {\n    this._front = null;\n    this._rear = null;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u957f\u5ea6 */\n  int size() {\n    return this._queSize;\n  }\n\n  /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return size() == 0;\n  }\n\n  /* \u5165\u961f\u64cd\u4f5c */\n  void push(int _num, bool isFront) {\n    final ListNode node = ListNode(_num);\n    if (isEmpty()) {\n      // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 _front \u548c _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;\n      node.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;\n      node.prev = _rear;\n      _rear = node; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    _queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n  }\n\n  /* \u961f\u9996\u5165\u961f */\n  void pushFirst(int _num) {\n    push(_num, true);\n  }\n\n  /* \u961f\u5c3e\u5165\u961f */\n  void pushLast(int _num) {\n    push(_num, false);\n  }\n\n  /* \u51fa\u961f\u64cd\u4f5c */\n  int? pop(bool isFront) {\n    // \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de null\n    if (isEmpty()) {\n      return null;\n    }\n    final int val;\n    if (isFront) {\n      // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n      val = _front!.val; // \u6682\u5b58\u5934\u8282\u70b9\u503c\n      // \u5220\u9664\u5934\u8282\u70b9\n      ListNode? fNext = _front!.next;\n      if (fNext != null) {\n        fNext.prev = null;\n        _front!.next = null;\n      }\n      _front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n    } else {\n      // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n      val = _rear!.val; // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n      // \u5220\u9664\u5c3e\u8282\u70b9\n      ListNode? rPrev = _rear!.prev;\n      if (rPrev != null) {\n        rPrev.next = null;\n        _rear!.prev = null;\n      }\n      _rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    _queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    return val;\n  }\n\n  /* \u961f\u9996\u51fa\u961f */\n  int? popFirst() {\n    return pop(true);\n  }\n\n  /* \u961f\u5c3e\u51fa\u961f */\n  int? popLast() {\n    return pop(false);\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int? peekFirst() {\n    return _front?.val;\n  }\n\n  /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n  int? peekLast() {\n    return _rear?.val;\n  }\n\n  /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n  List<int> toArray() {\n    ListNode? node = _front;\n    final List<int> res = [];\n    for (int i = 0; i < _queSize; i++) {\n      res.add(node!.val);\n      node = node.next;\n    }\n    return res;\n  }\n}\n
    linkedlist_deque.rs
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\npub struct ListNode<T> {\n    pub val: T,                                 // \u8282\u70b9\u503c\n    pub next: Option<Rc<RefCell<ListNode<T>>>>, // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n    pub prev: Option<Rc<RefCell<ListNode<T>>>>, // \u524d\u9a71\u8282\u70b9\u6307\u9488\n}\n\nimpl<T> ListNode<T> {\n    pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {\n        Rc::new(RefCell::new(ListNode {\n            val,\n            next: None,\n            prev: None,\n        }))\n    }\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\n#[allow(dead_code)]\npub struct LinkedListDeque<T> {\n    front: Option<Rc<RefCell<ListNode<T>>>>, // \u5934\u8282\u70b9 front\n    rear: Option<Rc<RefCell<ListNode<T>>>>,  // \u5c3e\u8282\u70b9 rear\n    que_size: usize,                         // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListDeque<T> {\n    pub fn new() -> Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.que_size;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    pub fn push(&mut self, num: T, is_front: bool) {\n        let node = ListNode::new(num);\n        // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        if is_front {\n            match self.front.take() {\n                // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n                None => {\n                    self.rear = Some(node.clone());\n                    self.front = Some(node);\n                }\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n                Some(old_front) => {\n                    old_front.borrow_mut().prev = Some(node.clone());\n                    node.borrow_mut().next = Some(old_front);\n                    self.front = Some(node); // \u66f4\u65b0\u5934\u8282\u70b9\n                }\n            }\n        }\n        // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n        else {\n            match self.rear.take() {\n                // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n                None => {\n                    self.front = Some(node.clone());\n                    self.rear = Some(node);\n                }\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n                Some(old_rear) => {\n                    old_rear.borrow_mut().next = Some(node.clone());\n                    node.borrow_mut().prev = Some(old_rear);\n                    self.rear = Some(node); // \u66f4\u65b0\u5c3e\u8282\u70b9\n                }\n            }\n        }\n        self.que_size += 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pub fn push_first(&mut self, num: T) {\n        self.push(num, true);\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pub fn push_last(&mut self, num: T) {\n        self.push(num, false);\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    pub fn pop(&mut self, is_front: bool) -> Option<T> {\n        // \u82e5\u961f\u5217\u4e3a\u7a7a\uff0c\u76f4\u63a5\u8fd4\u56de None\n        if self.is_empty() {\n            return None;\n        };\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if is_front {\n            self.front.take().map(|old_front| {\n                match old_front.borrow_mut().next.take() {\n                    Some(new_front) => {\n                        new_front.borrow_mut().prev.take();\n                        self.front = Some(new_front); // \u66f4\u65b0\u5934\u8282\u70b9\n                    }\n                    None => {\n                        self.rear.take();\n                    }\n                }\n                self.que_size -= 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n                Rc::try_unwrap(old_front).ok().unwrap().into_inner().val\n            })\n        }\n        // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        else {\n            self.rear.take().map(|old_rear| {\n                match old_rear.borrow_mut().prev.take() {\n                    Some(new_rear) => {\n                        new_rear.borrow_mut().next.take();\n                        self.rear = Some(new_rear); // \u66f4\u65b0\u5c3e\u8282\u70b9\n                    }\n                    None => {\n                        self.front.take();\n                    }\n                }\n                self.que_size -= 1; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n                Rc::try_unwrap(old_rear).ok().unwrap().into_inner().val\n            })\n        }\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    pub fn pop_first(&mut self) -> Option<T> {\n        return self.pop(true);\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    pub fn pop_last(&mut self) -> Option<T> {\n        return self.pop(false);\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    pub fn peek_first(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.front.as_ref()\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    pub fn peek_last(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.rear.as_ref()\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.insert(0, node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_deque.c
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\ntypedef struct DoublyListNode {\n    int val;                     // \u8282\u70b9\u503c\n    struct DoublyListNode *next; // \u540e\u7ee7\u8282\u70b9\n    struct DoublyListNode *prev; // \u524d\u9a71\u8282\u70b9\n} DoublyListNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nDoublyListNode *newDoublyListNode(int num) {\n    DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));\n    new->val = num;\n    new->next = NULL;\n    new->prev = NULL;\n    return new;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delDoublyListNode(DoublyListNode *node) {\n    free(node);\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntypedef struct {\n    DoublyListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize;                  // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n} LinkedListDeque;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListDeque *newLinkedListDeque() {\n    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));\n    deque->front = NULL;\n    deque->rear = NULL;\n    deque->queSize = 0;\n    return deque;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListdeque(LinkedListDeque *deque) {\n    // \u91ca\u653e\u6240\u6709\u8282\u70b9\n    for (int i = 0; i < deque->queSize && deque->front != NULL; i++) {\n        DoublyListNode *tmp = deque->front;\n        deque->front = deque->front->next;\n        free(tmp);\n    }\n    // \u91ca\u653e deque \u7ed3\u6784\u4f53\n    free(deque);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(LinkedListDeque *deque) {\n    return deque->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(LinkedListDeque *deque) {\n    return (size(deque) == 0);\n}\n\n/* \u5165\u961f */\nvoid push(LinkedListDeque *deque, int num, bool isFront) {\n    DoublyListNode *node = newDoublyListNode(num);\n    // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411node\n    if (empty(deque)) {\n        deque->front = deque->rear = node;\n    }\n    // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n    else if (isFront) {\n        // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n        deque->front->prev = node;\n        node->next = deque->front;\n        deque->front = node; // \u66f4\u65b0\u5934\u8282\u70b9\n    }\n    // \u961f\u5c3e\u5165\u961f\u64cd\u4f5c\n    else {\n        // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5c3e\u90e8\n        deque->rear->next = node;\n        node->prev = deque->rear;\n        deque->rear = node;\n    }\n    deque->queSize++; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n}\n\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(LinkedListDeque *deque, int num) {\n    push(deque, num, true);\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(LinkedListDeque *deque, int num) {\n    push(deque, num, false);\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(LinkedListDeque *deque) {\n    assert(size(deque) && deque->front);\n    return deque->front->val;\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(LinkedListDeque *deque) {\n    assert(size(deque) && deque->rear);\n    return deque->rear->val;\n}\n\n/* \u51fa\u961f */\nint pop(LinkedListDeque *deque, bool isFront) {\n    if (empty(deque))\n        return -1;\n    int val;\n    // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n    if (isFront) {\n        val = peekFirst(deque); // \u6682\u5b58\u5934\u8282\u70b9\u503c\n        DoublyListNode *fNext = deque->front->next;\n        if (fNext) {\n            fNext->prev = NULL;\n            deque->front->next = NULL;\n            delDoublyListNode(deque->front);\n        }\n        deque->front = fNext; // \u66f4\u65b0\u5934\u8282\u70b9\n    }\n    // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n    else {\n        val = peekLast(deque); // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n        DoublyListNode *rPrev = deque->rear->prev;\n        if (rPrev) {\n            rPrev->next = NULL;\n            deque->rear->prev = NULL;\n            delDoublyListNode(deque->rear);\n        }\n        deque->rear = rPrev; // \u66f4\u65b0\u5c3e\u8282\u70b9\n    }\n    deque->queSize--; // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    return val;\n}\n\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(LinkedListDeque *deque) {\n    return pop(deque, true);\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(LinkedListDeque *deque) {\n    return pop(deque, false);\n}\n\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListDeque(LinkedListDeque *deque) {\n    int *arr = malloc(sizeof(int) * deque->queSize);\n    // \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\n    int i;\n    DoublyListNode *node;\n    for (i = 0, node = deque->front; i < deque->queSize; i++) {\n        arr[i] = node->val;\n        node = node->next;\n    }\n    printArray(arr, deque->queSize);\n    free(arr);\n}\n
    linkedlist_deque.kt
    /* \u53cc\u5411\u94fe\u8868\u8282\u70b9 */\nclass ListNode(var value: Int) {\n    // \u8282\u70b9\u503c\n    var next: ListNode? = null // \u540e\u7ee7\u8282\u70b9\u5f15\u7528\n    var prev: ListNode? = null // \u524d\u9a71\u8282\u70b9\u5f15\u7528\n}\n\n/* \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass LinkedListDeque {\n    private var front: ListNode? = null // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private var rear: ListNode? = null\n    private var queSize = 0 // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u961f\u64cd\u4f5c */\n    fun push(num: Int, isFront: Boolean) {\n        val node = ListNode(num)\n        // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n        if (isEmpty()) {\n            rear = node\n            front = rear\n            // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n        } else if (isFront) {\n            // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n            front?.prev = node\n            node.next = front\n            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\n            rear?.next = node\n            node.prev = rear\n            rear = node // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize++ // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    fun pushFirst(num: Int) {\n        push(num, true)\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    fun pushLast(num: Int) {\n        push(num, false)\n    }\n\n    /* \u51fa\u961f\u64cd\u4f5c */\n    fun pop(isFront: Boolean): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n\n        val value: Int\n        // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n        if (isFront) {\n            value = front!!.value // \u6682\u5b58\u5934\u8282\u70b9\u503c\n            // \u5220\u9664\u5934\u8282\u70b9\n            val fNext = front!!.next\n            if (fNext != null) {\n                fNext.prev = null\n                front!!.next = null\n            }\n            front = fNext // \u66f4\u65b0\u5934\u8282\u70b9\n            // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n        } else {\n            value = rear!!.value // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n            // \u5220\u9664\u5c3e\u8282\u70b9\n            val rPrev = rear!!.prev\n            if (rPrev != null) {\n                rPrev.next = null\n                rear!!.prev = null\n            }\n            rear = rPrev // \u66f4\u65b0\u5c3e\u8282\u70b9\n        }\n        queSize-- // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        return value\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fun popFirst(): Int {\n        return pop(true)\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    fun popLast(): Int {\n        return pop(false)\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peekFirst(): Int {\n        if (isEmpty()) {\n            throw IndexOutOfBoundsException()\n\n        }\n        return front!!.value\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return rear!!.value\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!.value\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_deque.rb
    [class]{ListNode}-[func]{}\n\n[class]{LinkedListDeque}-[func]{}\n
    linkedlist_deque.zig
    // \u53cc\u5411\u94fe\u8868\u8282\u70b9\nfn ListNode(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        val: T = undefined,     // \u8282\u70b9\u503c\n        next: ?*Self = null,    // \u540e\u7ee7\u8282\u70b9\u6307\u9488\n        prev: ?*Self = null,    // \u524d\u9a71\u8282\u70b9\u6307\u9488\n\n        // Initialize a list node with specific value\n        pub fn init(self: *Self, x: i32) void {\n            self.val = x;\n            self.next = null;\n            self.prev = null;\n        }\n    };\n}\n\n// \u57fa\u4e8e\u53cc\u5411\u94fe\u8868\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\nfn LinkedListDeque(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        front: ?*ListNode(T) = null,                    // \u5934\u8282\u70b9 front\n        rear: ?*ListNode(T) = null,                     // \u5c3e\u8282\u70b9 rear\n        que_size: usize = 0,                             // \u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.front = null;\n            self.rear = null;\n            self.que_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.que_size;\n        }\n\n        // \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u5165\u961f\u64cd\u4f5c\n        pub fn push(self: *Self, num: T, is_front: bool) !void {\n            var node = try self.mem_allocator.create(ListNode(T));\n            node.init(num);\n            // \u82e5\u94fe\u8868\u4e3a\u7a7a\uff0c\u5219\u4ee4 front \u548c rear \u90fd\u6307\u5411 node\n            if (self.isEmpty()) {\n                self.front = node;\n                self.rear = node;\n            // \u961f\u9996\u5165\u961f\u64cd\u4f5c\n            } else if (is_front) {\n                // \u5c06 node \u6dfb\u52a0\u81f3\u94fe\u8868\u5934\u90e8\n                self.front.?.prev = node;\n                node.next = self.front;\n                self.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\n                self.rear.?.next = node;\n                node.prev = self.rear;\n                self.rear = node;   // \u66f4\u65b0\u5c3e\u8282\u70b9\n            }\n            self.que_size += 1;      // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n        } \n\n        // \u961f\u9996\u5165\u961f\n        pub fn pushFirst(self: *Self, num: T) !void {\n            try self.push(num, true);\n        } \n\n        // \u961f\u5c3e\u5165\u961f\n        pub fn pushLast(self: *Self, num: T) !void {\n            try self.push(num, false);\n        } \n\n        // \u51fa\u961f\u64cd\u4f5c\n        pub fn pop(self: *Self, is_front: bool) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            var val: T = undefined;\n            // \u961f\u9996\u51fa\u961f\u64cd\u4f5c\n            if (is_front) {\n                val = self.front.?.val;     // \u6682\u5b58\u5934\u8282\u70b9\u503c\n                // \u5220\u9664\u5934\u8282\u70b9\n                var fNext = self.front.?.next;\n                if (fNext != null) {\n                    fNext.?.prev = null;\n                    self.front.?.next = null;\n                }\n                self.front = fNext;         // \u66f4\u65b0\u5934\u8282\u70b9\n            // \u961f\u5c3e\u51fa\u961f\u64cd\u4f5c\n            } else {\n                val = self.rear.?.val;      // \u6682\u5b58\u5c3e\u8282\u70b9\u503c\n                // \u5220\u9664\u5c3e\u8282\u70b9\n                var rPrev = self.rear.?.prev;\n                if (rPrev != null) {\n                    rPrev.?.next = null;\n                    self.rear.?.prev = null;\n                }\n                self.rear = rPrev;          // \u66f4\u65b0\u5c3e\u8282\u70b9\n            }\n            self.que_size -= 1;              // \u66f4\u65b0\u961f\u5217\u957f\u5ea6\n            return val;\n        } \n\n        // \u961f\u9996\u51fa\u961f\n        pub fn popFirst(self: *Self) T {\n            return self.pop(true);\n        } \n\n        // \u961f\u5c3e\u51fa\u961f\n        pub fn popLast(self: *Self) T {\n            return self.pop(false);\n        } \n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peekFirst(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            return self.front.?.val;\n        }  \n\n        // \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\n        pub fn peekLast(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n            return self.rear.?.val;\n        }\n\n        // \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.front;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[i] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    "},{"location":"chapter_stack_and_queue/deque/#2","title":"2. \u00a0 \u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u5982\u56fe 5-9 \u6240\u793a\uff0c\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

    ArrayDequepush_last()push_first()pop_last()pop_first()

    \u56fe 5-9 \u00a0 \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u53cc\u5411\u961f\u5217\u7684\u5165\u961f\u51fa\u961f\u64cd\u4f5c

    \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_deque.py
    class ArrayDeque:\n    \"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217\"\"\"\n\n    def __init__(self, capacity: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._nums: list[int] = [0] * capacity\n        self._front: int = 0\n        self._size: int = 0\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\n        return len(self._nums)\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._size == 0\n\n    def 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\n        return (i + self.capacity()) % self.capacity()\n\n    def push_first(self, num: int):\n        \"\"\"\u961f\u9996\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        # \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        # \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        self._front = self.index(self._front - 1)\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        self._nums[self._front] = num\n        self._size += 1\n\n    def push_last(self, num: int):\n        \"\"\"\u961f\u5c3e\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        # \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        rear = self.index(self._front + self._size)\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop_first(self) -> int:\n        \"\"\"\u961f\u9996\u51fa\u961f\"\"\"\n        num = self.peek_first()\n        # \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        self._front = self.index(self._front + 1)\n        self._size -= 1\n        return num\n\n    def pop_last(self) -> int:\n        \"\"\"\u961f\u5c3e\u51fa\u961f\"\"\"\n        num = self.peek_last()\n        self._size -= 1\n        return num\n\n    def peek_first(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        return self._nums[self._front]\n\n    def peek_last(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u5c3e\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        # \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        last = self.index(self._front + self._size - 1)\n        return self._nums[last]\n\n    def 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\n        res = []\n        for i in range(self._size):\n            res.append(self._nums[self.index(self._front + i)])\n        return res\n
    array_deque.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n  private:\n    vector<int> nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;      // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    ArrayDeque(int capacity) {\n        nums.resize(capacity);\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    int capacity() {\n        return nums.size();\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    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\n        return (i + capacity()) % capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    void pushFirst(int num) {\n        if (queSize == capacity()) {\n            cout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    void pushLast(int num) {\n        if (queSize == capacity()) {\n            cout << \"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    int popFirst() {\n        int num = peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peekFirst() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    int peekLast() {\n        if (isEmpty())\n            throw out_of_range(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> res(queSize);\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n};\n
    array_deque.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private int[] nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayDeque(int capacity) {\n        this.nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private 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\n        return (i + capacity()) % capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void pushFirst(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    public void pushLast(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int popFirst() {\n        int num = peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int popLast() {\n        int num = peekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peekFirst() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int peekLast() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayDeque(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    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\n        return (i + Capacity()) % Capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    public void PushFirst(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    public void PushLast(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        int rear = Index(front + queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    public int PopFirst() {\n        int num = PeekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = Index(front + 1);\n        queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    public int PopLast() {\n        int num = PeekLast();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int PeekFirst() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        return nums[front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    public int PeekLast() {\n        if (IsEmpty()) {\n            throw new InvalidOperationException();\n        }\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        int last = Index(front + queSize - 1);\n        return nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[Index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntype arrayDeque struct {\n    nums        []int // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    queSize     int   // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n    queCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayDeque(queCapacity int) *arrayDeque {\n    return &arrayDeque{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayDeque) size() int {\n    return q.queSize\n}\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayDeque) isEmpty() bool {\n    return q.queSize == 0\n}\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\n    return (i + q.queCapacity) % q.queCapacity\n}\n\n/* \u961f\u9996\u5165\u961f */\nfunc (q *arrayDeque) pushFirst(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n        return\n    }\n    // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n    q.front = q.index(q.front - 1)\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n    q.nums[q.front] = num\n    q.queSize++\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nfunc (q *arrayDeque) pushLast(num int) {\n    if q.queSize == q.queCapacity {\n        fmt.Println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n        return\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    rear := q.index(q.front + q.queSize)\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* \u961f\u9996\u51fa\u961f */\nfunc (q *arrayDeque) popFirst() any {\n    num := q.peekFirst()\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    q.front = q.index(q.front + 1)\n    q.queSize--\n    return num\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nfunc (q *arrayDeque) popLast() any {\n    num := q.peekLast()\n    q.queSize--\n    return num\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayDeque) peekFirst() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nfunc (q *arrayDeque) peekLast() any {\n    if q.isEmpty() {\n        return nil\n    }\n    // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n    last := q.index(q.front + q.queSize - 1)\n    return q.nums[last]\n}\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\n    res := make([]int, q.queSize)\n    for i, j := 0, q.front; i < q.queSize; i++ {\n        res[i] = q.nums[q.index(j)]\n        j++\n    }\n    return res\n}\n
    array_deque.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var _size: Int // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(capacity: Int) {\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    func capacity() -> Int {\n        nums.count\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private 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\n    /* \u961f\u9996\u5165\u961f */\n    func pushFirst(num: Int) {\n        if size() == capacity() {\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        front = index(i: front - 1)\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        nums[front] = num\n        _size += 1\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    func pushLast(num: Int) {\n        if size() == capacity() {\n            print(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        let rear = index(i: front + size())\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    func popFirst() -> Int {\n        let num = peekFirst()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(i: front + 1)\n        _size -= 1\n        return num\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    func popLast() -> Int {\n        let num = peekLast()\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peekFirst() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return nums[front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    func peekLast() -> Int {\n        if isEmpty() {\n            fatalError(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        }\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        let last = index(i: front + size() - 1)\n        return nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    func toArray() -> [Int] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        (front ..< front + size()).map { nums[index(i: $0)] }\n    }\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\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n        this.#front = 0;\n        this.#queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    capacity() {\n        return this.#nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    index(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\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pushFirst(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        this.#front = this.index(this.#front - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        this.#nums[this.#front] = num;\n        this.#queSize++;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pushLast(num) {\n        if (this.#queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        const rear = this.index(this.#front + this.#queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    popFirst() {\n        const num = this.peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        this.#front = this.index(this.#front + 1);\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    popLast() {\n        const num = this.peekLast();\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.#nums[this.#front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast() {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        const last = this.index(this.#front + this.#queSize - 1);\n        return this.#nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const res = [];\n        for (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {\n            res[i] = this.#nums[this.index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n    private nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private queSize: number; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = 0;\n        this.queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    capacity(): number {\n        return this.nums.length;\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    index(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\n        return (i + this.capacity()) % this.capacity();\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pushFirst(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        this.front = this.index(this.front - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        this.nums[this.front] = num;\n        this.queSize++;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pushLast(num: number): void {\n        if (this.queSize === this.capacity()) {\n            console.log('\u53cc\u5411\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        const rear: number = this.index(this.front + this.queSize);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    popFirst(): number {\n        const num: number = this.peekFirst();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        this.front = this.index(this.front + 1);\n        this.queSize--;\n        return num;\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    popLast(): number {\n        const num: number = this.peekLast();\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peekFirst(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        return this.nums[this.front];\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    peekLast(): number {\n        if (this.isEmpty()) throw new Error('The Deque Is Empty.');\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        const last = this.index(this.front + this.queSize - 1);\n        return this.nums[last];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    toArray(): number[] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const res: number[] = [];\n        for (let i = 0, j = this.front; i < this.queSize; i++, j++) {\n            res[i] = this.nums[this.index(j)];\n        }\n        return res;\n    }\n}\n
    array_deque.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque {\n  late List<int> _nums; // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n  late int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n  late int _queSize; // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  ArrayDeque(int capacity) {\n    this._nums = List.filled(capacity, 0);\n    this._front = this._queSize = 0;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n  int capacity() {\n    return _nums.length;\n  }\n\n  /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n  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\n    return (i + capacity()) % capacity();\n  }\n\n  /* \u961f\u9996\u5165\u961f */\n  void pushFirst(int _num) {\n    if (_queSize == capacity()) {\n      throw 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\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\n  /* \u961f\u5c3e\u5165\u961f */\n  void pushLast(int _num) {\n    if (_queSize == capacity()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    int rear = index(_front + _queSize);\n    // \u5c06 _num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* \u961f\u9996\u51fa\u961f */\n  int popFirst() {\n    int _num = peekFirst();\n    // \u961f\u9996\u6307\u9488\u5411\u53f3\u79fb\u52a8\u4e00\u4f4d\n    _front = index(_front + 1);\n    _queSize--;\n    return _num;\n  }\n\n  /* \u961f\u5c3e\u51fa\u961f */\n  int popLast() {\n    int _num = peekLast();\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peekFirst() {\n    if (isEmpty()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n    }\n    return _nums[_front];\n  }\n\n  /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n  int peekLast() {\n    if (isEmpty()) {\n      throw Exception(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\");\n    }\n    // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n    int last = index(_front + _queSize - 1);\n    return _nums[last];\n  }\n\n  /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n  List<int> toArray() {\n    // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    List<int> res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i < _queSize; i++, j++) {\n      res[i] = _nums[index(j)];\n    }\n    return res;\n  }\n}\n
    array_deque.rs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nstruct ArrayDeque {\n    nums: Vec<i32>,  // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front: usize,    // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    que_size: usize, // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n}\n\nimpl ArrayDeque {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    pub fn new(capacity: usize) -> Self {\n        Self {\n            nums: vec![0; capacity],\n            front: 0,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    pub fn capacity(&self) -> usize {\n        self.nums.len()\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        self.que_size\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        self.que_size == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    fn index(&self, i: i32) -> usize {\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        return ((i + self.capacity() as i32) % self.capacity() as i32) as usize;\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    pub fn push_first(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u540e\u56de\u5230\u5c3e\u90e8\n        self.front = self.index(self.front as i32 - 1);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u9996\n        self.nums[self.front] = num;\n        self.que_size += 1;\n    }\n\n    /* \u961f\u5c3e\u5165\u961f */\n    pub fn push_last(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        let rear = self.index(self.front as i32 + self.que_size as i32);\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self.nums[rear] = num;\n        self.que_size += 1;\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fn pop_first(&mut self) -> i32 {\n        let num = self.peek_first();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        self.front = self.index(self.front as i32 + 1);\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u961f\u5c3e\u51fa\u961f */\n    fn pop_last(&mut self) -> i32 {\n        let num = self.peek_last();\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fn peek_first(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        };\n        self.nums[self.front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fn peek_last(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\")\n        };\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        let last = self.index(self.front as i32 + self.que_size as i32 - 1);\n        self.nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fn to_array(&self) -> Vec<i32> {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        let mut res = vec![0; self.que_size];\n        let mut j = self.front;\n        for i in 0..self.que_size {\n            res[i] = self.nums[self.index(j as i32)];\n            j += 1;\n        }\n        res\n    }\n}\n
    array_deque.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\ntypedef struct {\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n} ArrayDeque;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayDeque *newArrayDeque(int capacity) {\n    ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));\n    // \u521d\u59cb\u5316\u6570\u7ec4\n    deque->queCapacity = capacity;\n    deque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);\n    deque->front = deque->queSize = 0;\n    return deque;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayDeque(ArrayDeque *deque) {\n    free(deque->nums);\n    free(deque);\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(ArrayDeque *deque) {\n    return deque->queCapacity;\n}\n\n/* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\nint size(ArrayDeque *deque) {\n    return deque->queSize;\n}\n\n/* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(ArrayDeque *deque) {\n    return deque->queSize == 0;\n}\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\n    return ((i + capacity(deque)) % capacity(deque));\n}\n\n/* \u961f\u9996\u5165\u961f */\nvoid pushFirst(ArrayDeque *deque, int num) {\n    if (deque->queSize == capacity(deque)) {\n        printf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 front \u8d8a\u8fc7\u6570\u7ec4\u5934\u90e8\u56de\u5230\u5c3e\u90e8\n    deque->front = dequeIndex(deque, deque->front - 1);\n    // \u5c06 num \u6dfb\u52a0\u5230\u961f\u9996\n    deque->nums[deque->front] = num;\n    deque->queSize++;\n}\n\n/* \u961f\u5c3e\u5165\u961f */\nvoid pushLast(ArrayDeque *deque, int num) {\n    if (deque->queSize == capacity(deque)) {\n        printf(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    int rear = dequeIndex(deque, deque->front + deque->queSize);\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    deque->nums[rear] = num;\n    deque->queSize++;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peekFirst(ArrayDeque *deque) {\n    // \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\n    assert(empty(deque) == 0);\n    return deque->nums[deque->front];\n}\n\n/* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\nint peekLast(ArrayDeque *deque) {\n    // \u8bbf\u95ee\u5f02\u5e38\uff1a\u53cc\u5411\u961f\u5217\u4e3a\u7a7a\n    assert(empty(deque) == 0);\n    int last = dequeIndex(deque, deque->front + deque->queSize - 1);\n    return deque->nums[last];\n}\n\n/* \u961f\u9996\u51fa\u961f */\nint popFirst(ArrayDeque *deque) {\n    int num = peekFirst(deque);\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n    deque->front = dequeIndex(deque, deque->front + 1);\n    deque->queSize--;\n    return num;\n}\n\n/* \u961f\u5c3e\u51fa\u961f */\nint popLast(ArrayDeque *deque) {\n    int num = peekLast(deque);\n    deque->queSize--;\n    return num;\n}\n
    array_deque.kt
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u53cc\u5411\u961f\u5217 */\nclass ArrayDeque(capacity: Int) {\n    private var nums = IntArray(capacity) // \u7528\u4e8e\u5b58\u50a8\u53cc\u5411\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var queSize = 0 // \u53cc\u5411\u961f\u5217\u957f\u5ea6\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u5bb9\u91cf */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* \u83b7\u53d6\u53cc\u5411\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u53cc\u5411\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* \u8ba1\u7b97\u73af\u5f62\u6570\u7ec4\u7d22\u5f15 */\n    private fun 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        return (i + capacity()) % capacity()\n    }\n\n    /* \u961f\u9996\u5165\u961f */\n    fun pushFirst(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u961f\u9996\u6307\u9488\u5411\u5de6\u79fb\u52a8\u4e00\u4f4d\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\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\n    /* \u961f\u5c3e\u5165\u961f */\n    fun pushLast(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u53cc\u5411\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        val rear = index(front + queSize)\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        queSize++\n    }\n\n    /* \u961f\u9996\u51fa\u961f */\n    fun popFirst(): Int {\n        val num = peekFirst()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\n        front = index(front + 1)\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun popLast(): Int {\n        val num = peekLast()\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peekFirst(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* \u8bbf\u95ee\u961f\u5c3e\u5143\u7d20 */\n    fun peekLast(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        // \u8ba1\u7b97\u5c3e\u5143\u7d20\u7d22\u5f15\n        val last = index(front + queSize - 1)\n        return nums[last]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4\u7528\u4e8e\u6253\u5370 */\n    fun toArray(): IntArray {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i < queSize) {\n            res[i] = nums[index(j)]\n            i++\n            j++\n        }\n        return res\n    }\n}\n
    array_deque.rb
    [class]{ArrayDeque}-[func]{}\n
    array_deque.zig
    [class]{ArrayDeque}-[func]{}\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\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\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\u5c3e\u90e8\uff0c\u800c\u4f4d\u4e8e\u961f\u5217\u5934\u90e8\u7684\u4eba\u9010\u4e2a\u79bb\u5f00\u3002

    \u5982\u56fe 5-4 \u6240\u793a\uff0c\u6211\u4eec\u5c06\u961f\u5217\u5934\u90e8\u79f0\u4e3a\u201c\u961f\u9996\u201d\uff0c\u5c3e\u90e8\u79f0\u4e3a\u201c\u961f\u5c3e\u201d\uff0c\u5c06\u628a\u5143\u7d20\u52a0\u5165\u961f\u5c3e\u7684\u64cd\u4f5c\u79f0\u4e3a\u201c\u5165\u961f\u201d\uff0c\u5220\u9664\u961f\u9996\u5143\u7d20\u7684\u64cd\u4f5c\u79f0\u4e3a\u201c\u51fa\u961f\u201d\u3002

    \u56fe 5-4 \u00a0 \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\u8868 5-2 \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

    \u8868 5-2 \u00a0 \u961f\u5217\u64cd\u4f5c\u6548\u7387

    \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig queue.py
    from collections import deque\n\n# \u521d\u59cb\u5316\u961f\u5217\n# \u5728 Python \u4e2d\uff0c\u6211\u4eec\u4e00\u822c\u5c06\u53cc\u5411\u961f\u5217\u7c7b deque \u5f53\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\u63a8\u8350\nque: deque[int] = deque()\n\n# \u5143\u7d20\u5165\u961f\nque.append(1)\nque.append(3)\nque.append(2)\nque.append(5)\nque.append(4)\n\n# \u8bbf\u95ee\u961f\u9996\u5143\u7d20\nfront: int = que[0]\n\n# \u5143\u7d20\u51fa\u961f\npop: int = que.popleft()\n\n# \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\nsize: int = len(que)\n\n# \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(que) == 0\n
    queue.cpp
    /* \u521d\u59cb\u5316\u961f\u5217 */\nqueue<int> queue;\n\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint front = queue.front();\n\n/* \u5143\u7d20\u51fa\u961f */\nqueue.pop();\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.size();\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty = queue.empty();\n
    queue.java
    /* \u521d\u59cb\u5316\u961f\u5217 */\nQueue<Integer> queue = new LinkedList<>();\n\n/* \u5143\u7d20\u5165\u961f */\nqueue.offer(1);\nqueue.offer(3);\nqueue.offer(2);\nqueue.offer(5);\nqueue.offer(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.peek();\n\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.poll();\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.size();\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = queue.isEmpty();\n
    queue.cs
    /* \u521d\u59cb\u5316\u961f\u5217 */\nQueue<int> queue = new();\n\n/* \u5143\u7d20\u5165\u961f */\nqueue.Enqueue(1);\nqueue.Enqueue(3);\nqueue.Enqueue(2);\nqueue.Enqueue(5);\nqueue.Enqueue(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.Peek();\n\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.Dequeue();\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.Count;\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = queue.Count == 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\n/* \u5143\u7d20\u5165\u961f */\nqueue.PushBack(1)\nqueue.PushBack(3)\nqueue.PushBack(2)\nqueue.PushBack(5)\nqueue.PushBack(4)\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\npeek := queue.Front()\n\n/* \u5143\u7d20\u51fa\u961f */\npop := queue.Front()\nqueue.Remove(pop)\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nsize := queue.Len()\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nisEmpty := queue.Len() == 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\n/* \u5143\u7d20\u5165\u961f */\nqueue.append(1)\nqueue.append(3)\nqueue.append(2)\nqueue.append(5)\nqueue.append(4)\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nlet peek = queue.first!\n\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\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = queue.count\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = queue.isEmpty\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\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nconst peek = queue[0];\n\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\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = queue.length;\n\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\n/* \u5143\u7d20\u5165\u961f */\nqueue.push(1);\nqueue.push(3);\nqueue.push(2);\nqueue.push(5);\nqueue.push(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nconst peek = queue[0];\n\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\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nconst size = queue.length;\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nconst empty = queue.length === 0;\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\n/* \u5143\u7d20\u5165\u961f */\nqueue.add(1);\nqueue.add(3);\nqueue.add(2);\nqueue.add(5);\nqueue.add(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek = queue.first;\n\n/* \u5143\u7d20\u51fa\u961f */\nint pop = queue.removeFirst();\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size = queue.length;\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = queue.isEmpty;\n
    queue.rs
    /* \u521d\u59cb\u5316\u53cc\u5411\u961f\u5217 */\n// \u5728 Rust \u4e2d\u4f7f\u7528\u53cc\u5411\u961f\u5217\u4f5c\u4e3a\u666e\u901a\u961f\u5217\u6765\u4f7f\u7528\nlet mut deque: VecDeque<u32> = VecDeque::new();\n\n/* \u5143\u7d20\u5165\u961f */\ndeque.push_back(1);\ndeque.push_back(3);\ndeque.push_back(2);\ndeque.push_back(5);\ndeque.push_back(4);\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nif let Some(front) = deque.front() {\n}\n\n/* \u5143\u7d20\u51fa\u961f */\nif let Some(pop) = deque.pop_front() {\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nlet size = deque.len();\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = deque.is_empty();\n
    queue.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u961f\u5217\n
    queue.kt
    /* \u521d\u59cb\u5316\u961f\u5217 */\nval queue = LinkedList<Int>()\n\n/* \u5143\u7d20\u5165\u961f */\nqueue.offer(1)\nqueue.offer(3)\nqueue.offer(2)\nqueue.offer(5)\nqueue.offer(4)\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nval peek = queue.peek()\n\n/* \u5143\u7d20\u51fa\u961f */\nval pop = queue.poll()\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nval size = queue.size\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = queue.isEmpty()\n
    queue.rb
    \n
    queue.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\uff0c\u94fe\u8868\u548c\u6570\u7ec4\u90fd\u7b26\u5408\u8981\u6c42\u3002

    "},{"location":"chapter_stack_and_queue/queue/#1","title":"1. \u00a0 \u57fa\u4e8e\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u5982\u56fe 5-5 \u6240\u793a\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u94fe\u8868\u7684\u201c\u5934\u8282\u70b9\u201d\u548c\u201c\u5c3e\u8282\u70b9\u201d\u5206\u522b\u89c6\u4e3a\u201c\u961f\u9996\u201d\u548c\u201c\u961f\u5c3e\u201d\uff0c\u89c4\u5b9a\u961f\u5c3e\u4ec5\u53ef\u6dfb\u52a0\u8282\u70b9\uff0c\u961f\u9996\u4ec5\u53ef\u5220\u9664\u8282\u70b9\u3002

    LinkedListQueuepush()pop()

    \u56fe 5-5 \u00a0 \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u961f\u5217\u7684\u5165\u961f\u51fa\u961f\u64cd\u4f5c

    \u4ee5\u4e0b\u662f\u7528\u94fe\u8868\u5b9e\u73b0\u961f\u5217\u7684\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_queue.py
    class LinkedListQueue:\n    \"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._front: ListNode | None = None  # \u5934\u8282\u70b9 front\n        self._rear: ListNode | None = None  # \u5c3e\u8282\u70b9 rear\n        self._size: int = 0\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return not self._front\n\n    def push(self, num: int):\n        \"\"\"\u5165\u961f\"\"\"\n        # \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        node = ListNode(num)\n        # \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if self._front is None:\n            self._front = node\n            self._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:\n            self._rear.next = node\n            self._rear = node\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u961f\"\"\"\n        num = self.peek()\n        # \u5220\u9664\u5934\u8282\u70b9\n        self._front = self._front.next\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\n        return self._front.val\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        queue = []\n        temp = self._front\n        while temp:\n            queue.append(temp.val)\n            temp = temp.next\n        return queue\n
    linkedlist_queue.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n  private:\n    ListNode *front, *rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    int queSize;\n\n  public:\n    LinkedListQueue() {\n        front = nullptr;\n        rear = nullptr;\n        queSize = 0;\n    }\n\n    ~LinkedListQueue() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        freeMemoryLinkedList(front);\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    void push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode *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\n        if (front == nullptr) {\n            front = node;\n            rear = node;\n        }\n        // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n        else {\n            rear->next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    int pop() {\n        int num = peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        ListNode *tmp = front;\n        front = front->next;\n        // \u91ca\u653e\u5185\u5b58\n        delete tmp;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peek() {\n        if (size() == 0)\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        return front->val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        ListNode *node = front;\n        vector<int> res(size());\n        for (int i = 0; i < res.size(); i++) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_queue.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private ListNode front, rear; // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f */\n    public void push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode 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\n        if (front == null) {\n            front = node;\n            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 {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int pop() {\n        int num = peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front.next;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return front.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] toArray() {\n        ListNode node = front;\n        int[] res = new int[size()];\n        for (int i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    ListNode? front, rear;  // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear \n    int queSize = 0;\n\n    public LinkedListQueue() {\n        front = null;\n        rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u961f */\n    public void Push(int num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        ListNode node = new(num);\n        // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if (front == null) {\n            front = node;\n            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 if (rear != null) {\n            rear.next = node;\n            rear = node;\n        }\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int Pop() {\n        int num = Peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return front!.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        if (front == null)\n            return [];\n\n        ListNode? node = front;\n        int[] res = new int[Size()];\n        for (int i = 0; i < res.Length; i++) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newLinkedListQueue() *linkedListQueue {\n    return &linkedListQueue{\n        data: list.New(),\n    }\n}\n\n/* \u5165\u961f */\nfunc (s *linkedListQueue) push(value any) {\n    s.data.PushBack(value)\n}\n\n/* \u51fa\u961f */\nfunc (s *linkedListQueue) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (s *linkedListQueue) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Front()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (s *linkedListQueue) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListQueue) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListQueue) toList() *list.List {\n    return s.data\n}\n
    linkedlist_queue.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private var front: ListNode? // \u5934\u8282\u70b9\n    private var rear: ListNode? // \u5c3e\u8282\u70b9\n    private var _size: Int\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f */\n    func push(num: Int) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        let 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\n        if front == nil {\n            front = node\n            rear = node\n        }\n        // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n        else {\n            rear?.next = node\n            rear = node\n        }\n        _size += 1\n    }\n\n    /* \u51fa\u961f */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return front!.val\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        var node = front\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\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;\n\n    constructor() {\n        this.#front = null;\n        this.#rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        const 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\n        if (!this.#front) {\n            this.#front = node;\n            this.#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 {\n            this.#rear.next = node;\n            this.#rear = node;\n        }\n        this.#queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop() {\n        const num = this.peek();\n        // \u5220\u9664\u5934\u8282\u70b9\n        this.#front = this.#front.next;\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek() {\n        if (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.#front.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray() {\n        let node = this.#front;\n        const res = new Array(this.size);\n        for (let i = 0; i < res.length; i++) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n    private front: ListNode | null; // \u5934\u8282\u70b9 front\n    private rear: ListNode | null; // \u5c3e\u8282\u70b9 rear\n    private queSize: number = 0;\n\n    constructor() {\n        this.front = null;\n        this.rear = null;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num: number): void {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        const 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\n        if (!this.front) {\n            this.front = node;\n            this.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 {\n            this.rear!.next = node;\n            this.rear = node;\n        }\n        this.queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop(): number {\n        const num = this.peek();\n        if (!this.front) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        // \u5220\u9664\u5934\u8282\u70b9\n        this.front = this.front.next;\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek(): number {\n        if (this.size === 0) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.front!.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray(): number[] {\n        let node = this.front;\n        const res = new Array<number>(this.size);\n        for (let i = 0; i < res.length; i++) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_queue.dart
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue {\n  ListNode? _front; // \u5934\u8282\u70b9 _front\n  ListNode? _rear; // \u5c3e\u8282\u70b9 _rear\n  int _queSize = 0; // \u961f\u5217\u957f\u5ea6\n\n  LinkedListQueue() {\n    _front = null;\n    _rear = null;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u5165\u961f */\n  void push(int _num) {\n    // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 _num\n    final node = ListNode(_num);\n    // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n    if (_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\n  /* \u51fa\u961f */\n  int pop() {\n    final int _num = peek();\n    // \u5220\u9664\u5934\u8282\u70b9\n    _front = _front!.next;\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peek() {\n    if (_queSize == 0) {\n      throw Exception('\u961f\u5217\u4e3a\u7a7a');\n    }\n    return _front!.val;\n  }\n\n  /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n  List<int> toArray() {\n    ListNode? node = _front;\n    final List<int> queue = [];\n    while (node != null) {\n      queue.add(node.val);\n      node = node.next;\n    }\n    return queue;\n  }\n}\n
    linkedlist_queue.rs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\n#[allow(dead_code)]\npub struct LinkedListQueue<T> {\n    front: Option<Rc<RefCell<ListNode<T>>>>, // \u5934\u8282\u70b9 front\n    rear: Option<Rc<RefCell<ListNode<T>>>>,  // \u5c3e\u8282\u70b9 rear\n    que_size: usize,                         // \u961f\u5217\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListQueue<T> {\n    pub fn new() -> Self {\n        Self {\n            front: None,\n            rear: None,\n            que_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.que_size;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u961f */\n    pub fn push(&mut self, num: T) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        let new_rear = ListNode::new(num);\n        match self.rear.take() {\n            // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n            Some(old_rear) => {\n                old_rear.borrow_mut().next = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n            // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n            None => {\n                self.front = Some(new_rear.clone());\n                self.rear = Some(new_rear);\n            }\n        }\n        self.que_size += 1;\n    }\n\n    /* \u51fa\u961f */\n    pub fn pop(&mut self) -> Option<T> {\n        self.front.take().map(|old_front| {\n            match old_front.borrow_mut().next.take() {\n                Some(new_front) => {\n                    self.front = Some(new_front);\n                }\n                None => {\n                    self.rear.take();\n                }\n            }\n            self.que_size -= 1;\n            Rc::try_unwrap(old_front).ok().unwrap().into_inner().val\n        })\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.front.as_ref()\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.insert(0, node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_queue.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\ntypedef struct {\n    ListNode *front, *rear;\n    int queSize;\n} LinkedListQueue;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListQueue *newLinkedListQueue() {\n    LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));\n    queue->front = NULL;\n    queue->rear = NULL;\n    queue->queSize = 0;\n    return queue;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListQueue(LinkedListQueue *queue) {\n    // \u91ca\u653e\u6240\u6709\u8282\u70b9\n    while (queue->front != NULL) {\n        ListNode *tmp = queue->front;\n        queue->front = queue->front->next;\n        free(tmp);\n    }\n    // \u91ca\u653e queue \u7ed3\u6784\u4f53\n    free(queue);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(LinkedListQueue *queue) {\n    return queue->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(LinkedListQueue *queue) {\n    return (size(queue) == 0);\n}\n\n/* \u5165\u961f */\nvoid push(LinkedListQueue *queue, int num) {\n    // \u5c3e\u8282\u70b9\u5904\u6dfb\u52a0 node\n    ListNode *node = newListNode(num);\n    // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n    if (queue->front == NULL) {\n        queue->front = node;\n        queue->rear = node;\n    }\n    // \u5982\u679c\u961f\u5217\u4e0d\u4e3a\u7a7a\uff0c\u5219\u5c06\u8be5\u8282\u70b9\u6dfb\u52a0\u5230\u5c3e\u8282\u70b9\u540e\n    else {\n        queue->rear->next = node;\n        queue->rear = node;\n    }\n    queue->queSize++;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(LinkedListQueue *queue) {\n    assert(size(queue) && queue->front);\n    return queue->front->val;\n}\n\n/* \u51fa\u961f */\nint pop(LinkedListQueue *queue) {\n    int num = peek(queue);\n    ListNode *tmp = queue->front;\n    queue->front = queue->front->next;\n    free(tmp);\n    queue->queSize--;\n    return num;\n}\n\n/* \u6253\u5370\u961f\u5217 */\nvoid printLinkedListQueue(LinkedListQueue *queue) {\n    int *arr = malloc(sizeof(int) * queue->queSize);\n    // \u62f7\u8d1d\u94fe\u8868\u4e2d\u7684\u6570\u636e\u5230\u6570\u7ec4\n    int i;\n    ListNode *node;\n    for (i = 0, node = queue->front; i < queue->queSize; i++) {\n        arr[i] = node->val;\n        node = node->next;\n    }\n    printArray(arr, queue->queSize);\n    free(arr);\n}\n
    linkedlist_queue.kt
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217 */\nclass LinkedListQueue(\n    // \u5934\u8282\u70b9 front \uff0c\u5c3e\u8282\u70b9 rear\n    private var front: ListNode? = null,\n    private var rear: ListNode? = null,\n    private var queSize: Int = 0\n) {\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u961f */\n    fun push(num: Int) {\n        // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n        val node = ListNode(num)\n        // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n        if (front == null) {\n            front = node\n            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 {\n            rear?.next = node\n            rear = node\n        }\n        queSize++\n    }\n\n    /* \u51fa\u961f */\n    fun pop(): Int {\n        val num = peek()\n        // \u5220\u9664\u5934\u8282\u70b9\n        front = front?.next\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return front!!.value\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): IntArray {\n        var node = front\n        val res = IntArray(size())\n        for (i in res.indices) {\n            res[i] = node!!.value\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_queue.rb
    [class]{LinkedListQueue}-[func]{}\n
    linkedlist_queue.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u961f\u5217\nfn LinkedListQueue(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        front: ?*inc.ListNode(T) = null,                // \u5934\u8282\u70b9 front\n        rear: ?*inc.ListNode(T) = null,                 // \u5c3e\u8282\u70b9 rear\n        que_size: usize = 0,                            // \u961f\u5217\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u961f\u5217\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.front = null;\n            self.rear = null;\n            self.que_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.que_size;\n        }\n\n        // \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.size() == 0) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\n            return self.front.?.val;\n        }  \n\n        // \u5165\u961f\n        pub fn push(self: *Self, num: T) !void {\n            // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n            var node = try self.mem_allocator.create(inc.ListNode(T));\n            node.init(num);\n            // \u5982\u679c\u961f\u5217\u4e3a\u7a7a\uff0c\u5219\u4ee4\u5934\u3001\u5c3e\u8282\u70b9\u90fd\u6307\u5411\u8be5\u8282\u70b9\n            if (self.front == null) {\n                self.front = node;\n                self.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 {\n                self.rear.?.next = node;\n                self.rear = node;\n            }\n            self.que_size += 1;\n        } \n\n        // \u51fa\u961f\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            // \u5220\u9664\u5934\u8282\u70b9\n            self.front = self.front.?.next;\n            self.que_size -= 1;\n            return num;\n        } \n\n        // \u5c06\u94fe\u8868\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.front;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[i] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_stack_and_queue/queue/#2","title":"2. \u00a0 \u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u5728\u6570\u7ec4\u4e2d\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 size \u7528\u4e8e\u8bb0\u5f55\u961f\u5217\u957f\u5ea6\u3002\u5b9a\u4e49 rear = front + size \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\u5404\u79cd\u64cd\u4f5c\u7684\u5b9e\u73b0\u65b9\u6cd5\u5982\u56fe 5-6 \u6240\u793a\u3002

    • \u5165\u961f\u64cd\u4f5c\uff1a\u5c06\u8f93\u5165\u5143\u7d20\u8d4b\u503c\u7ed9 rear \u7d22\u5f15\u5904\uff0c\u5e76\u5c06 size \u589e\u52a0 1 \u3002
    • \u51fa\u961f\u64cd\u4f5c\uff1a\u53ea\u9700\u5c06 front \u589e\u52a0 1 \uff0c\u5e76\u5c06 size \u51cf\u5c11 1 \u3002

    \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()

    \u56fe 5-6 \u00a0 \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u961f\u5217\u7684\u5165\u961f\u51fa\u961f\u64cd\u4f5c

    \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\u4e86\u89e3\u51b3\u6b64\u95ee\u9898\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u89c6\u4e3a\u9996\u5c3e\u76f8\u63a5\u7684\u201c\u73af\u5f62\u6570\u7ec4\u201d\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_queue.py
    class ArrayQueue:\n    \"\"\"\u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\"\"\"\n\n    def __init__(self, size: int):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._nums: list[int] = [0] * size  # \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n        self._front: int = 0  # \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n        self._size: int = 0  # \u961f\u5217\u957f\u5ea6\n\n    def capacity(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\"\"\"\n        return len(self._nums)\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._size == 0\n\n    def push(self, num: int):\n        \"\"\"\u5165\u961f\"\"\"\n        if self._size == self.capacity():\n            raise IndexError(\"\u961f\u5217\u5df2\u6ee1\")\n        # \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        # \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        rear: int = (self._front + self._size) % self.capacity()\n        # \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self._nums[rear] = num\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u961f\"\"\"\n        num: int = self.peek()\n        # \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        self._front = (self._front + 1) % self.capacity()\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u961f\u9996\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u961f\u5217\u4e3a\u7a7a\")\n        return self._nums[self._front]\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        res = [0] * self.size()\n        j: int = self._front\n        for i in range(self.size()):\n            res[i] = self._nums[(j % self.capacity())]\n            j += 1\n        return res\n
    array_queue.cpp
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n  private:\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u961f\u5217\u957f\u5ea6\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n\n  public:\n    ArrayQueue(int capacity) {\n        // \u521d\u59cb\u5316\u6570\u7ec4\n        nums = new int[capacity];\n        queCapacity = capacity;\n        front = queSize = 0;\n    }\n\n    ~ArrayQueue() {\n        delete[] nums;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    int capacity() {\n        return queCapacity;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u961f */\n    void push(int num) {\n        if (queSize == queCapacity) {\n            cout << \"\u961f\u5217\u5df2\u6ee1\" << endl;\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % queCapacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    int pop() {\n        int num = peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % queCapacity;\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    int peek() {\n        if (isEmpty())\n            throw out_of_range(\"\u961f\u5217\u4e3a\u7a7a\");\n        return nums[front];\n    }\n\n    /* \u5c06\u6570\u7ec4\u8f6c\u5316\u4e3a Vector \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        vector<int> arr(queSize);\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            arr[i] = nums[j % queCapacity];\n        }\n        return arr;\n    }\n};\n
    array_queue.java
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private int[] nums; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private int front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private int queSize; // \u961f\u5217\u957f\u5ea6\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    public int capacity() {\n        return nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    public void push(int num) {\n        if (queSize == capacity()) {\n            System.out.println(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % capacity();\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int pop() {\n        int num = peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return nums[front];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    public int[] toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[j % capacity()];\n        }\n        return res;\n    }\n}\n
    array_queue.cs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    int[] nums;  // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize; // \u961f\u5217\u957f\u5ea6\n\n    public ArrayQueue(int capacity) {\n        nums = new int[capacity];\n        front = queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    int Capacity() {\n        return nums.Length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    public int Size() {\n        return queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return queSize == 0;\n    }\n\n    /* \u5165\u961f */\n    public void Push(int num) {\n        if (queSize == Capacity()) {\n            Console.WriteLine(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        int rear = (front + queSize) % Capacity();\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num;\n        queSize++;\n    }\n\n    /* \u51fa\u961f */\n    public int Pop() {\n        int num = Peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % Capacity();\n        queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return nums[front];\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    public int[] ToArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        int[] res = new int[queSize];\n        for (int i = 0, j = front; i < queSize; i++, j++) {\n            res[i] = nums[j % this.Capacity()];\n        }\n        return res;\n    }\n}\n
    array_queue.go
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntype arrayQueue struct {\n    nums        []int // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front       int   // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    queSize     int   // \u961f\u5217\u957f\u5ea6\n    queCapacity int   // \u961f\u5217\u5bb9\u91cf\uff08\u5373\u6700\u5927\u5bb9\u7eb3\u5143\u7d20\u6570\u91cf\uff09\n}\n\n/* \u521d\u59cb\u5316\u961f\u5217 */\nfunc newArrayQueue(queCapacity int) *arrayQueue {\n    return &arrayQueue{\n        nums:        make([]int, queCapacity),\n        queCapacity: queCapacity,\n        front:       0,\n        queSize:     0,\n    }\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nfunc (q *arrayQueue) size() int {\n    return q.queSize\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nfunc (q *arrayQueue) isEmpty() bool {\n    return q.queSize == 0\n}\n\n/* \u5165\u961f */\nfunc (q *arrayQueue) push(num int) {\n    // \u5f53 rear == queCapacity \u8868\u793a\u961f\u5217\u5df2\u6ee1\n    if q.queSize == q.queCapacity {\n        return\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    rear := (q.front + q.queSize) % q.queCapacity\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    q.nums[rear] = num\n    q.queSize++\n}\n\n/* \u51fa\u961f */\nfunc (q *arrayQueue) pop() any {\n    num := q.peek()\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    q.front = (q.front + 1) % q.queCapacity\n    q.queSize--\n    return num\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nfunc (q *arrayQueue) peek() any {\n    if q.isEmpty() {\n        return nil\n    }\n    return q.nums[q.front]\n}\n\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (q *arrayQueue) toSlice() []int {\n    rear := (q.front + q.queSize)\n    if rear >= q.queCapacity {\n        rear %= q.queCapacity\n        return append(q.nums[q.front:], q.nums[:rear]...)\n    }\n    return q.nums[q.front:rear]\n}\n
    array_queue.swift
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private var nums: [Int] // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front: Int // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var _size: Int // \u961f\u5217\u957f\u5ea6\n\n    init(capacity: Int) {\n        // \u521d\u59cb\u5316\u6570\u7ec4\n        nums = Array(repeating: 0, count: capacity)\n        front = 0\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    func capacity() -> Int {\n        nums.count\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u961f */\n    func push(num: Int) {\n        if size() == capacity() {\n            print(\"\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        let rear = (front + size()) % capacity()\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        _size += 1\n    }\n\n    /* \u51fa\u961f */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity()\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u961f\u5217\u4e3a\u7a7a\")\n        }\n        return nums[front]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    func toArray() -> [Int] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        (front ..< front + size()).map { nums[$0 % capacity()] }\n    }\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\n\n    constructor(capacity) {\n        this.#nums = new Array(capacity);\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    get capacity() {\n        return this.#nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#queSize === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num) {\n        if (this.size === this.capacity) {\n            console.log('\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        const rear = (this.#front + this.size) % this.capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.#nums[rear] = num;\n        this.#queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop() {\n        const num = this.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        this.#front = (this.#front + 1) % this.capacity;\n        this.#queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek() {\n        if (this.isEmpty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.#nums[this.#front];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.#front; i < this.size; i++, j++) {\n            arr[i] = this.#nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n
    array_queue.ts
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n    private nums: number[]; // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private front: number; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private queSize: number; // \u961f\u5217\u957f\u5ea6\n\n    constructor(capacity: number) {\n        this.nums = new Array(capacity);\n        this.front = this.queSize = 0;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    get capacity(): number {\n        return this.nums.length;\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.queSize;\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.queSize === 0;\n    }\n\n    /* \u5165\u961f */\n    push(num: number): void {\n        if (this.size === this.capacity) {\n            console.log('\u961f\u5217\u5df2\u6ee1');\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        const rear = (this.front + this.queSize) % this.capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        this.nums[rear] = num;\n        this.queSize++;\n    }\n\n    /* \u51fa\u961f */\n    pop(): number {\n        const num = this.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        this.front = (this.front + 1) % this.capacity;\n        this.queSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    peek(): number {\n        if (this.isEmpty()) throw new Error('\u961f\u5217\u4e3a\u7a7a');\n        return this.nums[this.front];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray(): number[] {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        const arr = new Array(this.size);\n        for (let i = 0, j = this.front; i < this.size; i++, j++) {\n            arr[i] = this.nums[j % this.capacity];\n        }\n        return arr;\n    }\n}\n
    array_queue.dart
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue {\n  late List<int> _nums; // \u7528\u4e8e\u50a8\u5b58\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n  late int _front; // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n  late int _queSize; // \u961f\u5217\u957f\u5ea6\n\n  ArrayQueue(int capacity) {\n    _nums = List.filled(capacity, 0);\n    _front = _queSize = 0;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n  int capaCity() {\n    return _nums.length;\n  }\n\n  /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n  int size() {\n    return _queSize;\n  }\n\n  /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _queSize == 0;\n  }\n\n  /* \u5165\u961f */\n  void push(int _num) {\n    if (_queSize == capaCity()) {\n      throw Exception(\"\u961f\u5217\u5df2\u6ee1\");\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    int rear = (_front + _queSize) % capaCity();\n    // \u5c06 _num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    _nums[rear] = _num;\n    _queSize++;\n  }\n\n  /* \u51fa\u961f */\n  int pop() {\n    int _num = peek();\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    _front = (_front + 1) % capaCity();\n    _queSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"\u961f\u5217\u4e3a\u7a7a\");\n    }\n    return _nums[_front];\n  }\n\n  /* \u8fd4\u56de Array */\n  List<int> toArray() {\n    // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n    final List<int> res = List.filled(_queSize, 0);\n    for (int i = 0, j = _front; i < _queSize; i++, j++) {\n      res[i] = _nums[j % capaCity()];\n    }\n    return res;\n  }\n}\n
    array_queue.rs
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nstruct ArrayQueue {\n    nums: Vec<i32>,    // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    front: i32,        // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    que_size: i32,     // \u961f\u5217\u957f\u5ea6\n    que_capacity: i32, // \u961f\u5217\u5bb9\u91cf\n}\n\nimpl ArrayQueue {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(capacity: i32) -> ArrayQueue {\n        ArrayQueue {\n            nums: vec![0; capacity as usize],\n            front: 0,\n            que_size: 0,\n            que_capacity: capacity,\n        }\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    fn capacity(&self) -> i32 {\n        self.que_capacity\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fn size(&self) -> i32 {\n        self.que_size\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fn is_empty(&self) -> bool {\n        self.que_size == 0\n    }\n\n    /* \u5165\u961f */\n    fn push(&mut self, num: i32) {\n        if self.que_size == self.capacity() {\n            println!(\"\u961f\u5217\u5df2\u6ee1\");\n            return;\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        let rear = (self.front + self.que_size) % self.que_capacity;\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        self.nums[rear as usize] = num;\n        self.que_size += 1;\n    }\n\n    /* \u51fa\u961f */\n    fn pop(&mut self) -> i32 {\n        let num = self.peek();\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        self.front = (self.front + 1) % self.que_capacity;\n        self.que_size -= 1;\n        num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fn peek(&self) -> i32 {\n        if self.is_empty() {\n            panic!(\"index out of bounds\");\n        }\n        self.nums[self.front as usize]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    fn to_vector(&self) -> Vec<i32> {\n        let cap = self.que_capacity;\n        let mut j = self.front;\n        let mut arr = vec![0; self.que_size as usize];\n        for i in 0..self.que_size {\n            arr[i as usize] = self.nums[(j % cap) as usize];\n            j += 1;\n        }\n        arr\n    }\n}\n
    array_queue.c
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\ntypedef struct {\n    int *nums;       // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    int front;       // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    int queSize;     // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n    int queCapacity; // \u961f\u5217\u5bb9\u91cf\n} ArrayQueue;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayQueue *newArrayQueue(int capacity) {\n    ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));\n    // \u521d\u59cb\u5316\u6570\u7ec4\n    queue->queCapacity = capacity;\n    queue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);\n    queue->front = queue->queSize = 0;\n    return queue;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayQueue(ArrayQueue *queue) {\n    free(queue->nums);\n    free(queue);\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\nint capacity(ArrayQueue *queue) {\n    return queue->queCapacity;\n}\n\n/* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\nint size(ArrayQueue *queue) {\n    return queue->queSize;\n}\n\n/* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\nbool empty(ArrayQueue *queue) {\n    return queue->queSize == 0;\n}\n\n/* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\nint peek(ArrayQueue *queue) {\n    assert(size(queue) != 0);\n    return queue->nums[queue->front];\n}\n\n/* \u5165\u961f */\nvoid push(ArrayQueue *queue, int num) {\n    if (size(queue) == capacity(queue)) {\n        printf(\"\u961f\u5217\u5df2\u6ee1\\r\\n\");\n        return;\n    }\n    // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n    // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n    int rear = (queue->front + queue->queSize) % queue->queCapacity;\n    // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n    queue->nums[rear] = num;\n    queue->queSize++;\n}\n\n/* \u51fa\u961f */\nint pop(ArrayQueue *queue) {\n    int num = peek(queue);\n    // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n    queue->front = (queue->front + 1) % queue->queCapacity;\n    queue->queSize--;\n    return num;\n}\n
    array_queue.kt
    /* \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217 */\nclass ArrayQueue(capacity: Int) {\n    private val nums = IntArray(capacity) // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4\n    private var front = 0 // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n    private var queSize = 0 // \u961f\u5217\u957f\u5ea6\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf */\n    fun capacity(): Int {\n        return nums.size\n    }\n\n    /* \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return queSize\n    }\n\n    /* \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return queSize == 0\n    }\n\n    /* \u5165\u961f */\n    fun push(num: Int) {\n        if (queSize == capacity()) {\n            println(\"\u961f\u5217\u5df2\u6ee1\")\n            return\n        }\n        // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n        // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n        val rear = (front + queSize) % capacity()\n        // \u5c06 num \u6dfb\u52a0\u81f3\u961f\u5c3e\n        nums[rear] = num\n        queSize++\n    }\n\n    /* \u51fa\u961f */\n    fun pop(): Int {\n        val num = peek()\n        // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n        front = (front + 1) % capacity()\n        queSize--\n        return num\n    }\n\n    /* \u8bbf\u95ee\u961f\u9996\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return nums[front]\n    }\n\n    /* \u8fd4\u56de\u6570\u7ec4 */\n    fun toArray(): IntArray {\n        // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n        val res = IntArray(queSize)\n        var i = 0\n        var j = front\n        while (i < queSize) {\n            res[i] = nums[j % capacity()]\n            i++\n            j++\n        }\n        return res\n    }\n}\n
    array_queue.rb
    [class]{ArrayQueue}-[func]{}\n
    array_queue.zig
    // \u57fa\u4e8e\u73af\u5f62\u6570\u7ec4\u5b9e\u73b0\u7684\u961f\u5217\nfn ArrayQueue(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        nums: []T = undefined,                          // \u7528\u4e8e\u5b58\u50a8\u961f\u5217\u5143\u7d20\u7684\u6570\u7ec4     \n        cap: usize = 0,                                 // \u961f\u5217\u5bb9\u91cf\n        front: usize = 0,                               // \u961f\u9996\u6307\u9488\uff0c\u6307\u5411\u961f\u9996\u5143\u7d20\n        queSize: usize = 0,                             // \u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e + 1\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,   // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6570\u7ec4\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator, cap: usize) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.cap = cap;\n            self.nums = try self.mem_allocator.alloc(T, self.cap);\n            @memset(self.nums, @as(T, 0));\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u5bb9\u91cf\n        pub fn capacity(self: *Self) usize {\n            return self.cap;\n        }\n\n        // \u83b7\u53d6\u961f\u5217\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.queSize;\n        }\n\n        // \u5224\u65ad\u961f\u5217\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.queSize == 0;\n        }\n\n        // \u5165\u961f\n        pub fn push(self: *Self, num: T) !void {\n            if (self.size() == self.capacity()) {\n                std.debug.print(\"\u961f\u5217\u5df2\u6ee1\\n\", .{});\n                return;\n            }\n            // \u8ba1\u7b97\u961f\u5c3e\u6307\u9488\uff0c\u6307\u5411\u961f\u5c3e\u7d22\u5f15 + 1\n            // \u901a\u8fc7\u53d6\u4f59\u64cd\u4f5c\u5b9e\u73b0 rear \u8d8a\u8fc7\u6570\u7ec4\u5c3e\u90e8\u540e\u56de\u5230\u5934\u90e8\n            var rear = (self.front + self.queSize) % self.capacity();\n            // \u5728\u5c3e\u8282\u70b9\u540e\u6dfb\u52a0 num\n            self.nums[rear] = num;\n            self.queSize += 1;\n        } \n\n        // \u51fa\u961f\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            // \u961f\u9996\u6307\u9488\u5411\u540e\u79fb\u52a8\u4e00\u4f4d\uff0c\u82e5\u8d8a\u8fc7\u5c3e\u90e8\uff0c\u5219\u8fd4\u56de\u5230\u6570\u7ec4\u5934\u90e8\n            self.front = (self.front + 1) % self.capacity();\n            self.queSize -= 1;\n            return num;\n        } \n\n        // \u8bbf\u95ee\u961f\u9996\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u961f\u5217\u4e3a\u7a7a\");\n            return self.nums[self.front];\n        } \n\n        // \u8fd4\u56de\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            // \u4ec5\u8f6c\u6362\u6709\u6548\u957f\u5ea6\u8303\u56f4\u5185\u7684\u5217\u8868\u5143\u7d20\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            var j: usize = self.front;\n            while (i < self.size()) : ({ i += 1; j += 1; }) {\n                res[i] = self.nums[j % self.capacity()];\n            }\n            return res;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \u4ee5\u4e0a\u5b9e\u73b0\u7684\u961f\u5217\u4ecd\u7136\u5177\u6709\u5c40\u9650\u6027\uff1a\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\u8bfb\u8005\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\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\uff0c\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\u903b\u8f91\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\u60f3\u53d6\u51fa\u5e95\u90e8\u7684\u76d8\u5b50\uff0c\u5219\u9700\u8981\u5148\u5c06\u4e0a\u9762\u7684\u76d8\u5b50\u4f9d\u6b21\u79fb\u8d70\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\u8fd9\u79cd\u6570\u636e\u7ed3\u6784\u3002

    \u5982\u56fe 5-1 \u6240\u793a\uff0c\u6211\u4eec\u628a\u5806\u53e0\u5143\u7d20\u7684\u9876\u90e8\u79f0\u4e3a\u201c\u6808\u9876\u201d\uff0c\u5e95\u90e8\u79f0\u4e3a\u201c\u6808\u5e95\u201d\u3002\u5c06\u628a\u5143\u7d20\u6dfb\u52a0\u5230\u6808\u9876\u7684\u64cd\u4f5c\u53eb\u4f5c\u201c\u5165\u6808\u201d\uff0c\u5220\u9664\u6808\u9876\u5143\u7d20\u7684\u64cd\u4f5c\u53eb\u4f5c\u201c\u51fa\u6808\u201d\u3002

    \u56fe 5-1 \u00a0 \u6808\u7684\u5148\u5165\u540e\u51fa\u89c4\u5219

    "},{"location":"chapter_stack_and_queue/stack/#511","title":"5.1.1 \u00a0 \u6808\u7684\u5e38\u7528\u64cd\u4f5c","text":"

    \u6808\u7684\u5e38\u7528\u64cd\u4f5c\u5982\u8868 5-1 \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()\u3001pop()\u3001peek() \u547d\u540d\u4e3a\u4f8b\u3002

    \u8868 5-1 \u00a0 \u6808\u7684\u64cd\u4f5c\u6548\u7387

    \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\u201c\u6570\u7ec4\u201d\u6216\u201c\u94fe\u8868\u201d\u5f53\u4f5c\u6808\u6765\u4f7f\u7528\uff0c\u5e76\u5728\u7a0b\u5e8f\u903b\u8f91\u4e0a\u5ffd\u7565\u4e0e\u6808\u65e0\u5173\u7684\u64cd\u4f5c\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n# \u5143\u7d20\u5165\u6808\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n# \u8bbf\u95ee\u6808\u9876\u5143\u7d20\npeek: int = stack[-1]\n\n# \u5143\u7d20\u51fa\u6808\npop: int = stack.pop()\n\n# \u83b7\u53d6\u6808\u7684\u957f\u5ea6\nsize: int = len(stack)\n\n# \u5224\u65ad\u662f\u5426\u4e3a\u7a7a\nis_empty: bool = len(stack) == 0\n
    stack.cpp
    /* \u521d\u59cb\u5316\u6808 */\nstack<int> stack;\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint top = stack.top();\n\n/* \u5143\u7d20\u51fa\u6808 */\nstack.pop(); // \u65e0\u8fd4\u56de\u503c\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.size();\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool empty = stack.empty();\n
    stack.java
    /* \u521d\u59cb\u5316\u6808 */\nStack<Integer> stack = new Stack<>();\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.peek();\n\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.pop();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.size();\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nboolean isEmpty = stack.isEmpty();\n
    stack.cs
    /* \u521d\u59cb\u5316\u6808 */\nStack<int> stack = new();\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.Push(1);\nstack.Push(3);\nstack.Push(2);\nstack.Push(5);\nstack.Push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.Peek();\n\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.Pop();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.Count;\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = stack.Count == 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\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\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\npeek := stack[len(stack)-1]\n\n/* \u5143\u7d20\u51fa\u6808 */\npop := stack[len(stack)-1]\nstack = stack[:len(stack)-1]\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nsize := len(stack)\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nisEmpty := len(stack) == 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\n/* \u5143\u7d20\u5165\u6808 */\nstack.append(1)\nstack.append(3)\nstack.append(2)\nstack.append(5)\nstack.append(4)\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nlet peek = stack.last!\n\n/* \u5143\u7d20\u51fa\u6808 */\nlet pop = stack.removeLast()\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nlet size = stack.count\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nlet isEmpty = stack.isEmpty\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\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nconst peek = stack[stack.length-1];\n\n/* \u5143\u7d20\u51fa\u6808 */\nconst pop = stack.pop();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nconst size = stack.length;\n\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\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nconst peek = stack[stack.length - 1];\n\n/* \u5143\u7d20\u51fa\u6808 */\nconst pop = stack.pop();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nconst size = stack.length;\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nconst is_empty = stack.length === 0;\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\n/* \u5143\u7d20\u5165\u6808 */\nstack.add(1);\nstack.add(3);\nstack.add(2);\nstack.add(5);\nstack.add(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek = stack.last;\n\n/* \u5143\u7d20\u51fa\u6808 */\nint pop = stack.removeLast();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size = stack.length;\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty = stack.isEmpty;\n
    stack.rs
    /* \u521d\u59cb\u5316\u6808 */\n// \u628a Vec \u5f53\u4f5c\u6808\u6765\u4f7f\u7528\nlet mut stack: Vec<i32> = Vec::new();\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1);\nstack.push(3);\nstack.push(2);\nstack.push(5);\nstack.push(4);\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nlet top = stack.last().unwrap();\n\n/* \u5143\u7d20\u51fa\u6808 */\nlet pop = stack.pop().unwrap();\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nlet size = stack.len();\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nlet is_empty = stack.is_empty();\n
    stack.c
    // C \u672a\u63d0\u4f9b\u5185\u7f6e\u6808\n
    stack.kt
    /* \u521d\u59cb\u5316\u6808 */\nval stack = Stack<Int>()\n\n/* \u5143\u7d20\u5165\u6808 */\nstack.push(1)\nstack.push(3)\nstack.push(2)\nstack.push(5)\nstack.push(4)\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nval peek = stack.peek()\n\n/* \u5143\u7d20\u51fa\u6808 */\nval pop = stack.pop()\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nval size = stack.size\n\n/* \u5224\u65ad\u662f\u5426\u4e3a\u7a7a */\nval isEmpty = stack.isEmpty()\n
    stack.rb
    \n
    stack.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"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\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":"1. \u00a0 \u57fa\u4e8e\u94fe\u8868\u7684\u5b9e\u73b0","text":"

    \u4f7f\u7528\u94fe\u8868\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

    \u5982\u56fe 5-2 \u6240\u793a\uff0c\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()

    \u56fe 5-2 \u00a0 \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u6808\u7684\u5165\u6808\u51fa\u6808\u64cd\u4f5c

    \u4ee5\u4e0b\u662f\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u6808\u7684\u793a\u4f8b\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig linkedlist_stack.py
    class LinkedListStack:\n    \"\"\"\u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._peek: ListNode | None = None\n        self._size: int = 0\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\n        return self._size\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return not self._peek\n\n    def push(self, val: int):\n        \"\"\"\u5165\u6808\"\"\"\n        node = ListNode(val)\n        node.next = self._peek\n        self._peek = node\n        self._size += 1\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u6808\"\"\"\n        num = self.peek()\n        self._peek = self._peek.next\n        self._size -= 1\n        return num\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._peek.val\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8f6c\u5316\u4e3a\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        arr = []\n        node = self._peek\n        while node:\n            arr.append(node.val)\n            node = node.next\n        arr.reverse()\n        return arr\n
    linkedlist_stack.cpp
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n  private:\n    ListNode *stackTop; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int stkSize;        // \u6808\u7684\u957f\u5ea6\n\n  public:\n    LinkedListStack() {\n        stackTop = nullptr;\n        stkSize = 0;\n    }\n\n    ~LinkedListStack() {\n        // \u904d\u5386\u94fe\u8868\u5220\u9664\u8282\u70b9\uff0c\u91ca\u653e\u5185\u5b58\n        freeMemoryLinkedList(stackTop);\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    int size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    void push(int num) {\n        ListNode *node = new ListNode(num);\n        node->next = stackTop;\n        stackTop = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    int pop() {\n        int num = top();\n        ListNode *tmp = stackTop;\n        stackTop = stackTop->next;\n        // \u91ca\u653e\u5185\u5b58\n        delete tmp;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"\u6808\u4e3a\u7a7a\");\n        return stackTop->val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    vector<int> toVector() {\n        ListNode *node = stackTop;\n        vector<int> res(size());\n        for (int i = res.size() - 1; i >= 0; i--) {\n            res[i] = node->val;\n            node = node->next;\n        }\n        return res;\n    }\n};\n
    linkedlist_stack.java
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private ListNode stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private int stkSize = 0; // \u6808\u7684\u957f\u5ea6\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void push(int num) {\n        ListNode node = new ListNode(num);\n        node.next = stackPeek;\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    public int pop() {\n        int num = peek();\n        stackPeek = stackPeek.next;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stackPeek.val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] toArray() {\n        ListNode node = stackPeek;\n        int[] res = new int[size()];\n        for (int i = res.length - 1; i >= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.cs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    ListNode? stackPeek;  // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int stkSize = 0;   // \u6808\u7684\u957f\u5ea6\n\n    public LinkedListStack() {\n        stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int Size() {\n        return stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void Push(int num) {\n        ListNode node = new(num) {\n            next = stackPeek\n        };\n        stackPeek = node;\n        stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    public int Pop() {\n        int num = Peek();\n        stackPeek = stackPeek!.next;\n        stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stackPeek!.val;\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        if (stackPeek == null)\n            return [];\n\n        ListNode? node = stackPeek;\n        int[] res = new int[Size()];\n        for (int i = res.Length - 1; i >= 0; i--) {\n            res[i] = node!.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\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\n    data *list.List\n}\n\n/* \u521d\u59cb\u5316\u6808 */\nfunc newLinkedListStack() *linkedListStack {\n    return &linkedListStack{\n        data: list.New(),\n    }\n}\n\n/* \u5165\u6808 */\nfunc (s *linkedListStack) push(value int) {\n    s.data.PushBack(value)\n}\n\n/* \u51fa\u6808 */\nfunc (s *linkedListStack) pop() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    s.data.Remove(e)\n    return e.Value\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nfunc (s *linkedListStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    e := s.data.Back()\n    return e.Value\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nfunc (s *linkedListStack) size() int {\n    return s.data.Len()\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *linkedListStack) isEmpty() bool {\n    return s.data.Len() == 0\n}\n\n/* \u83b7\u53d6 List \u7528\u4e8e\u6253\u5370 */\nfunc (s *linkedListStack) toList() *list.List {\n    return s.data\n}\n
    linkedlist_stack.swift
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private var _peek: ListNode? // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private var _size: Int // \u6808\u7684\u957f\u5ea6\n\n    init() {\n        _size = 0\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        _size\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        size() == 0\n    }\n\n    /* \u5165\u6808 */\n    func push(num: Int) {\n        let node = ListNode(x: num)\n        node.next = _peek\n        _peek = node\n        _size += 1\n    }\n\n    /* \u51fa\u6808 */\n    @discardableResult\n    func pop() -> Int {\n        let num = peek()\n        _peek = _peek?.next\n        _size -= 1\n        return num\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return _peek!.val\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        var node = _peek\n        var res = Array(repeating: 0, count: size())\n        for i in res.indices.reversed() {\n            res[i] = node!.val\n            node = node?.next\n        }\n        return res\n    }\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\n\n    constructor() {\n        this.#stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.size === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num) {\n        const node = new ListNode(num);\n        node.next = this.#stackPeek;\n        this.#stackPeek = node;\n        this.#stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    pop() {\n        const num = this.peek();\n        this.#stackPeek = this.#stackPeek.next;\n        this.#stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    peek() {\n        if (!this.#stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stackPeek.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray() {\n        let node = this.#stackPeek;\n        const res = new Array(this.size);\n        for (let i = res.length - 1; i >= 0; i--) {\n            res[i] = node.val;\n            node = node.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.ts
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n    private stackPeek: ListNode | null; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private stkSize: number = 0; // \u6808\u7684\u957f\u5ea6\n\n    constructor() {\n        this.stackPeek = null;\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.stkSize;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.size === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num: number): void {\n        const node = new ListNode(num);\n        node.next = this.stackPeek;\n        this.stackPeek = node;\n        this.stkSize++;\n    }\n\n    /* \u51fa\u6808 */\n    pop(): number {\n        const num = this.peek();\n        if (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        this.stackPeek = this.stackPeek.next;\n        this.stkSize--;\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    peek(): number {\n        if (!this.stackPeek) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stackPeek.val;\n    }\n\n    /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    toArray(): number[] {\n        let node = this.stackPeek;\n        const res = new Array<number>(this.size);\n        for (let i = res.length - 1; i >= 0; i--) {\n            res[i] = node!.val;\n            node = node!.next;\n        }\n        return res;\n    }\n}\n
    linkedlist_stack.dart
    /* \u57fa\u4e8e\u94fe\u8868\u7c7b\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack {\n  ListNode? _stackPeek; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n  int _stkSize = 0; // \u6808\u7684\u957f\u5ea6\n\n  LinkedListStack() {\n    _stackPeek = null;\n  }\n\n  /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n  int size() {\n    return _stkSize;\n  }\n\n  /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _stkSize == 0;\n  }\n\n  /* \u5165\u6808 */\n  void push(int _num) {\n    final ListNode node = ListNode(_num);\n    node.next = _stackPeek;\n    _stackPeek = node;\n    _stkSize++;\n  }\n\n  /* \u51fa\u6808 */\n  int pop() {\n    final int _num = peek();\n    _stackPeek = _stackPeek!.next;\n    _stkSize--;\n    return _num;\n  }\n\n  /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n  int peek() {\n    if (_stackPeek == null) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stackPeek!.val;\n  }\n\n  /* \u5c06\u94fe\u8868\u8f6c\u5316\u4e3a List \u5e76\u8fd4\u56de */\n  List<int> toList() {\n    ListNode? node = _stackPeek;\n    List<int> list = [];\n    while (node != null) {\n      list.add(node.val);\n      node = node.next;\n    }\n    list = list.reversed.toList();\n    return list;\n  }\n}\n
    linkedlist_stack.rs
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\n#[allow(dead_code)]\npub struct LinkedListStack<T> {\n    stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    stk_size: usize,                              // \u6808\u7684\u957f\u5ea6\n}\n\nimpl<T: Copy> LinkedListStack<T> {\n    pub fn new() -> Self {\n        Self {\n            stack_peek: None,\n            stk_size: 0,\n        }\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    pub fn size(&self) -> usize {\n        return self.stk_size;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    pub fn is_empty(&self) -> bool {\n        return self.size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    pub fn push(&mut self, num: T) {\n        let node = ListNode::new(num);\n        node.borrow_mut().next = self.stack_peek.take();\n        self.stack_peek = Some(node);\n        self.stk_size += 1;\n    }\n\n    /* \u51fa\u6808 */\n    pub fn pop(&mut self) -> Option<T> {\n        self.stack_peek.take().map(|old_head| {\n            match old_head.borrow_mut().next.take() {\n                Some(new_head) => {\n                    self.stack_peek = Some(new_head);\n                }\n                None => {\n                    self.stack_peek = None;\n                }\n            }\n            self.stk_size -= 1;\n            Rc::try_unwrap(old_head).ok().unwrap().into_inner().val\n        })\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {\n        self.stack_peek.as_ref()\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {\n        if let Some(node) = head {\n            let mut nums = self.to_array(node.borrow().next.as_ref());\n            nums.push(node.borrow().val);\n            return nums;\n        }\n        return Vec::new();\n    }\n}\n
    linkedlist_stack.c
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\ntypedef struct {\n    ListNode *top; // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    int size;      // \u6808\u7684\u957f\u5ea6\n} LinkedListStack;\n\n/* \u6784\u9020\u51fd\u6570 */\nLinkedListStack *newLinkedListStack() {\n    LinkedListStack *s = malloc(sizeof(LinkedListStack));\n    s->top = NULL;\n    s->size = 0;\n    return s;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delLinkedListStack(LinkedListStack *s) {\n    while (s->top) {\n        ListNode *n = s->top->next;\n        free(s->top);\n        s->top = n;\n    }\n    free(s);\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(LinkedListStack *s) {\n    return s->size;\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(LinkedListStack *s) {\n    return size(s) == 0;\n}\n\n/* \u5165\u6808 */\nvoid push(LinkedListStack *s, int num) {\n    ListNode *node = (ListNode *)malloc(sizeof(ListNode));\n    node->next = s->top; // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6307\u9488\u57df\n    node->val = num;     // \u66f4\u65b0\u65b0\u52a0\u8282\u70b9\u6570\u636e\u57df\n    s->top = node;       // \u66f4\u65b0\u6808\u9876\n    s->size++;           // \u66f4\u65b0\u6808\u5927\u5c0f\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(LinkedListStack *s) {\n    if (s->size == 0) {\n        printf(\"\u6808\u4e3a\u7a7a\\n\");\n        return INT_MAX;\n    }\n    return s->top->val;\n}\n\n/* \u51fa\u6808 */\nint pop(LinkedListStack *s) {\n    int val = peek(s);\n    ListNode *tmp = s->top;\n    s->top = s->top->next;\n    // \u91ca\u653e\u5185\u5b58\n    free(tmp);\n    s->size--;\n    return val;\n}\n
    linkedlist_stack.kt
    /* \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808 */\nclass LinkedListStack(\n    private var stackPeek: ListNode? = null, // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n    private var stkSize: Int = 0 // \u6808\u7684\u957f\u5ea6\n) {\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return stkSize\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fun push(num: Int) {\n        val node = ListNode(num)\n        node.next = stackPeek\n        stackPeek = node\n        stkSize++\n    }\n\n    /* \u51fa\u6808 */\n    fun pop(): Int? {\n        val num = peek()\n        stackPeek = stackPeek?.next\n        stkSize--;\n        return num\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fun peek(): Int? {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stackPeek?.value\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): IntArray {\n        var node = stackPeek\n        val res = IntArray(size())\n        for (i in res.size - 1 downTo 0) {\n            res[i] = node?.value!!\n            node = node.next\n        }\n        return res\n    }\n}\n
    linkedlist_stack.rb
    [class]{LinkedListStack}-[func]{}\n
    linkedlist_stack.zig
    // \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\nfn LinkedListStack(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        stack_top: ?*inc.ListNode(T) = null,             // \u5c06\u5934\u8282\u70b9\u4f5c\u4e3a\u6808\u9876\n        stk_size: usize = 0,                             // \u6808\u7684\u957f\u5ea6\n        mem_arena: ?std.heap.ArenaAllocator = null,\n        mem_allocator: std.mem.Allocator = undefined,    // \u5185\u5b58\u5206\u914d\u5668\n\n        // \u6784\u9020\u51fd\u6570\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {\n            if (self.mem_arena == null) {\n                self.mem_arena = std.heap.ArenaAllocator.init(allocator);\n                self.mem_allocator = self.mem_arena.?.allocator();\n            }\n            self.stack_top = null;\n            self.stk_size = 0;\n        }\n\n        // \u6790\u6784\u51fd\u6570\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.mem_arena == null) return;\n            self.mem_arena.?.deinit();\n        }\n\n        // \u83b7\u53d6\u6808\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.stk_size;\n        }\n\n        // \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u6808\u9876\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.size() == 0) @panic(\"\u6808\u4e3a\u7a7a\");\n            return self.stack_top.?.val;\n        }  \n\n        // \u5165\u6808\n        pub fn push(self: *Self, num: T) !void {\n            var node = try self.mem_allocator.create(inc.ListNode(T));\n            node.init(num);\n            node.next = self.stack_top;\n            self.stack_top = node;\n            self.stk_size += 1;\n        } \n\n        // \u51fa\u6808\n        pub fn pop(self: *Self) T {\n            var num = self.peek();\n            self.stack_top = self.stack_top.?.next;\n            self.stk_size -= 1;\n            return num;\n        } \n\n        // \u5c06\u6808\u8f6c\u6362\u4e3a\u6570\u7ec4\n        pub fn toArray(self: *Self) ![]T {\n            var node = self.stack_top;\n            var res = try self.mem_allocator.alloc(T, self.size());\n            @memset(res, @as(T, 0));\n            var i: usize = 0;\n            while (i < res.len) : (i += 1) {\n                res[res.len - i - 1] = node.?.val;\n                node = node.?.next;\n            }\n            return res;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_stack_and_queue/stack/#2","title":"2. \u00a0 \u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0","text":"

    \u4f7f\u7528\u6570\u7ec4\u5b9e\u73b0\u6808\u65f6\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u6570\u7ec4\u7684\u5c3e\u90e8\u4f5c\u4e3a\u6808\u9876\u3002\u5982\u56fe 5-3 \u6240\u793a\uff0c\u5165\u6808\u4e0e\u51fa\u6808\u64cd\u4f5c\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()

    \u56fe 5-3 \u00a0 \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u6808\u7684\u5165\u6808\u51fa\u6808\u64cd\u4f5c

    \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\u987b\u81ea\u884c\u5904\u7406\u6570\u7ec4\u6269\u5bb9\u95ee\u9898\u3002\u4ee5\u4e0b\u4e3a\u793a\u4f8b\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_stack.py
    class ArrayStack:\n    \"\"\"\u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\"\"\"\n\n    def __init__(self):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._stack: list[int] = []\n\n    def size(self) -> int:\n        \"\"\"\u83b7\u53d6\u6808\u7684\u957f\u5ea6\"\"\"\n        return len(self._stack)\n\n    def is_empty(self) -> bool:\n        \"\"\"\u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\"\"\"\n        return self._stack == []\n\n    def push(self, item: int):\n        \"\"\"\u5165\u6808\"\"\"\n        self._stack.append(item)\n\n    def pop(self) -> int:\n        \"\"\"\u51fa\u6808\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._stack.pop()\n\n    def peek(self) -> int:\n        \"\"\"\u8bbf\u95ee\u6808\u9876\u5143\u7d20\"\"\"\n        if self.is_empty():\n            raise IndexError(\"\u6808\u4e3a\u7a7a\")\n        return self._stack[-1]\n\n    def to_list(self) -> list[int]:\n        \"\"\"\u8fd4\u56de\u5217\u8868\u7528\u4e8e\u6253\u5370\"\"\"\n        return self._stack\n
    array_stack.cpp
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n  private:\n    vector<int> stack;\n\n  public:\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    int size() {\n        return stack.size();\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    bool isEmpty() {\n        return stack.size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    void push(int num) {\n        stack.push_back(num);\n    }\n\n    /* \u51fa\u6808 */\n    int pop() {\n        int num = top();\n        stack.pop_back();\n        return num;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    int top() {\n        if (isEmpty())\n            throw out_of_range(\"\u6808\u4e3a\u7a7a\");\n        return stack.back();\n    }\n\n    /* \u8fd4\u56de Vector */\n    vector<int> toVector() {\n        return stack;\n    }\n};\n
    array_stack.java
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private ArrayList<Integer> stack;\n\n    public ArrayStack() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = new ArrayList<>();\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int size() {\n        return stack.size();\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public boolean isEmpty() {\n        return size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void push(int num) {\n        stack.add(num);\n    }\n\n    /* \u51fa\u6808 */\n    public int pop() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.remove(size() - 1);\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int peek() {\n        if (isEmpty())\n            throw new IndexOutOfBoundsException();\n        return stack.get(size() - 1);\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public Object[] toArray() {\n        return stack.toArray();\n    }\n}\n
    array_stack.cs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    List<int> stack;\n    public ArrayStack() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    public int Size() {\n        return stack.Count;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    public bool IsEmpty() {\n        return Size() == 0;\n    }\n\n    /* \u5165\u6808 */\n    public void Push(int num) {\n        stack.Add(num);\n    }\n\n    /* \u51fa\u6808 */\n    public int Pop() {\n        if (IsEmpty())\n            throw new Exception();\n        var val = Peek();\n        stack.RemoveAt(Size() - 1);\n        return val;\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    public int Peek() {\n        if (IsEmpty())\n            throw new Exception();\n        return stack[Size() - 1];\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    public int[] ToArray() {\n        return [.. stack];\n    }\n}\n
    array_stack.go
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntype arrayStack struct {\n    data []int // \u6570\u636e\n}\n\n/* \u521d\u59cb\u5316\u6808 */\nfunc newArrayStack() *arrayStack {\n    return &arrayStack{\n        // \u8bbe\u7f6e\u6808\u7684\u957f\u5ea6\u4e3a 0\uff0c\u5bb9\u91cf\u4e3a 16\n        data: make([]int, 0, 16),\n    }\n}\n\n/* \u6808\u7684\u957f\u5ea6 */\nfunc (s *arrayStack) size() int {\n    return len(s.data)\n}\n\n/* \u6808\u662f\u5426\u4e3a\u7a7a */\nfunc (s *arrayStack) isEmpty() bool {\n    return s.size() == 0\n}\n\n/* \u5165\u6808 */\nfunc (s *arrayStack) push(v int) {\n    // \u5207\u7247\u4f1a\u81ea\u52a8\u6269\u5bb9\n    s.data = append(s.data, v)\n}\n\n/* \u51fa\u6808 */\nfunc (s *arrayStack) pop() any {\n    val := s.peek()\n    s.data = s.data[:len(s.data)-1]\n    return val\n}\n\n/* \u83b7\u53d6\u6808\u9876\u5143\u7d20 */\nfunc (s *arrayStack) peek() any {\n    if s.isEmpty() {\n        return nil\n    }\n    val := s.data[len(s.data)-1]\n    return val\n}\n\n/* \u83b7\u53d6 Slice \u7528\u4e8e\u6253\u5370 */\nfunc (s *arrayStack) toSlice() []int {\n    return s.data\n}\n
    array_stack.swift
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private var stack: [Int]\n\n    init() {\n        // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n        stack = []\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    func size() -> Int {\n        stack.count\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    func isEmpty() -> Bool {\n        stack.isEmpty\n    }\n\n    /* \u5165\u6808 */\n    func push(num: Int) {\n        stack.append(num)\n    }\n\n    /* \u51fa\u6808 */\n    @discardableResult\n    func pop() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return stack.removeLast()\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    func peek() -> Int {\n        if isEmpty() {\n            fatalError(\"\u6808\u4e3a\u7a7a\")\n        }\n        return stack.last!\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    func toArray() -> [Int] {\n        stack\n    }\n}\n
    array_stack.js
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    #stack;\n    constructor() {\n        this.#stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size() {\n        return this.#stack.length;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty() {\n        return this.#stack.length === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num) {\n        this.#stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    pop() {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stack.pop();\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    top() {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.#stack[this.#stack.length - 1];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        return this.#stack;\n    }\n}\n
    array_stack.ts
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    private stack: number[];\n    constructor() {\n        this.stack = [];\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    get size(): number {\n        return this.stack.length;\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    isEmpty(): boolean {\n        return this.stack.length === 0;\n    }\n\n    /* \u5165\u6808 */\n    push(num: number): void {\n        this.stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    pop(): number | undefined {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stack.pop();\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    top(): number | undefined {\n        if (this.isEmpty()) throw new Error('\u6808\u4e3a\u7a7a');\n        return this.stack[this.stack.length - 1];\n    }\n\n    /* \u8fd4\u56de Array */\n    toArray() {\n        return this.stack;\n    }\n}\n
    array_stack.dart
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n  late List<int> _stack;\n  ArrayStack() {\n    _stack = [];\n  }\n\n  /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n  int size() {\n    return _stack.length;\n  }\n\n  /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n  bool isEmpty() {\n    return _stack.isEmpty;\n  }\n\n  /* \u5165\u6808 */\n  void push(int _num) {\n    _stack.add(_num);\n  }\n\n  /* \u51fa\u6808 */\n  int pop() {\n    if (isEmpty()) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stack.removeLast();\n  }\n\n  /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n  int peek() {\n    if (isEmpty()) {\n      throw Exception(\"\u6808\u4e3a\u7a7a\");\n    }\n    return _stack.last;\n  }\n\n  /* \u5c06\u6808\u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n  List<int> toArray() => _stack;\n}\n
    array_stack.rs
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nstruct ArrayStack<T> {\n    stack: Vec<T>,\n}\n\nimpl<T> ArrayStack<T> {\n    /* \u521d\u59cb\u5316\u6808 */\n    fn new() -> ArrayStack<T> {\n        ArrayStack::<T> {\n            stack: Vec::<T>::new(),\n        }\n    }\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fn size(&self) -> usize {\n        self.stack.len()\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fn is_empty(&self) -> bool {\n        self.size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fn push(&mut self, num: T) {\n        self.stack.push(num);\n    }\n\n    /* \u51fa\u6808 */\n    fn pop(&mut self) -> Option<T> {\n        self.stack.pop()\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fn peek(&self) -> Option<&T> {\n        if self.is_empty() {\n            panic!(\"\u6808\u4e3a\u7a7a\")\n        };\n        self.stack.last()\n    }\n\n    /* \u8fd4\u56de &Vec */\n    fn to_array(&self) -> &Vec<T> {\n        &self.stack\n    }\n}\n
    array_stack.c
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\ntypedef struct {\n    int *data;\n    int size;\n} ArrayStack;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayStack *newArrayStack() {\n    ArrayStack *stack = malloc(sizeof(ArrayStack));\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5927\u5bb9\u91cf\uff0c\u907f\u514d\u6269\u5bb9\n    stack->data = malloc(sizeof(int) * MAX_SIZE);\n    stack->size = 0;\n    return stack;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayStack(ArrayStack *stack) {\n    free(stack->data);\n    free(stack);\n}\n\n/* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\nint size(ArrayStack *stack) {\n    return stack->size;\n}\n\n/* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\nbool isEmpty(ArrayStack *stack) {\n    return stack->size == 0;\n}\n\n/* \u5165\u6808 */\nvoid push(ArrayStack *stack, int num) {\n    if (stack->size == MAX_SIZE) {\n        printf(\"\u6808\u5df2\u6ee1\\n\");\n        return;\n    }\n    stack->data[stack->size] = num;\n    stack->size++;\n}\n\n/* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\nint peek(ArrayStack *stack) {\n    if (stack->size == 0) {\n        printf(\"\u6808\u4e3a\u7a7a\\n\");\n        return INT_MAX;\n    }\n    return stack->data[stack->size - 1];\n}\n\n/* \u51fa\u6808 */\nint pop(ArrayStack *stack) {\n    int val = peek(stack);\n    stack->size--;\n    return val;\n}\n
    array_stack.kt
    /* \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808 */\nclass ArrayStack {\n    // \u521d\u59cb\u5316\u5217\u8868\uff08\u52a8\u6001\u6570\u7ec4\uff09\n    private val stack = ArrayList<Int>()\n\n    /* \u83b7\u53d6\u6808\u7684\u957f\u5ea6 */\n    fun size(): Int {\n        return stack.size\n    }\n\n    /* \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a */\n    fun isEmpty(): Boolean {\n        return size() == 0\n    }\n\n    /* \u5165\u6808 */\n    fun push(num: Int) {\n        stack.add(num)\n    }\n\n    /* \u51fa\u6808 */\n    fun pop(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack.removeAt(size() - 1)\n    }\n\n    /* \u8bbf\u95ee\u6808\u9876\u5143\u7d20 */\n    fun peek(): Int {\n        if (isEmpty()) throw IndexOutOfBoundsException()\n        return stack[size() - 1]\n    }\n\n    /* \u5c06 List \u8f6c\u5316\u4e3a Array \u5e76\u8fd4\u56de */\n    fun toArray(): Array<Any> {\n        return stack.toArray()\n    }\n}\n
    array_stack.rb
    [class]{ArrayStack}-[func]{}\n
    array_stack.zig
    // \u57fa\u4e8e\u6570\u7ec4\u5b9e\u73b0\u7684\u6808\nfn ArrayStack(comptime T: type) type {\n    return struct {\n        const Self = @This();\n\n        stack: ?std.ArrayList(T) = null,     \n\n        // \u6784\u9020\u65b9\u6cd5\uff08\u5206\u914d\u5185\u5b58+\u521d\u59cb\u5316\u6808\uff09\n        pub fn init(self: *Self, allocator: std.mem.Allocator) void {\n            if (self.stack == null) {\n                self.stack = std.ArrayList(T).init(allocator);\n            }\n        }\n\n        // \u6790\u6784\u65b9\u6cd5\uff08\u91ca\u653e\u5185\u5b58\uff09\n        pub fn deinit(self: *Self) void {\n            if (self.stack == null) return;\n            self.stack.?.deinit();\n        }\n\n        // \u83b7\u53d6\u6808\u7684\u957f\u5ea6\n        pub fn size(self: *Self) usize {\n            return self.stack.?.items.len;\n        }\n\n        // \u5224\u65ad\u6808\u662f\u5426\u4e3a\u7a7a\n        pub fn isEmpty(self: *Self) bool {\n            return self.size() == 0;\n        }\n\n        // \u8bbf\u95ee\u6808\u9876\u5143\u7d20\n        pub fn peek(self: *Self) T {\n            if (self.isEmpty()) @panic(\"\u6808\u4e3a\u7a7a\");\n            return self.stack.?.items[self.size() - 1];\n        }  \n\n        // \u5165\u6808\n        pub fn push(self: *Self, num: T) !void {\n            try self.stack.?.append(num);\n        } \n\n        // \u51fa\u6808\n        pub fn pop(self: *Self) T {\n            var num = self.stack.?.pop();\n            return num;\n        } \n\n        // \u8fd4\u56de ArrayList\n        pub fn toList(self: *Self) std.ArrayList(T) {\n            return self.stack.?;\n        }\n    };\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_stack_and_queue/stack/#513","title":"5.1.3 \u00a0 \u4e24\u79cd\u5b9e\u73b0\u5bf9\u6bd4","text":"

    \u652f\u6301\u64cd\u4f5c

    \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

    \u65f6\u95f4\u6548\u7387

    \u5728\u57fa\u4e8e\u6570\u7ec4\u7684\u5b9e\u73b0\u4e2d\uff0c\u5165\u6808\u548c\u51fa\u6808\u64cd\u4f5c\u90fd\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\u57fa\u4e8e\u94fe\u8868\u7684\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\u65f6\uff0c\u4f8b\u5982 int \u6216 double \uff0c\u6211\u4eec\u53ef\u4ee5\u5f97\u51fa\u4ee5\u4e0b\u7ed3\u8bba\u3002

    • \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\u3002
    • \u57fa\u4e8e\u94fe\u8868\u5b9e\u73b0\u7684\u6808\u53ef\u4ee5\u63d0\u4f9b\u66f4\u52a0\u7a33\u5b9a\u7684\u6548\u7387\u8868\u73b0\u3002

    \u7a7a\u95f4\u6548\u7387

    \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\u51fa\u5b9e\u9645\u9700\u6c42\uff1b\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\u7684\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\u7684\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\u5bf9\u4e0a\u4e00\u4e2a\u7f51\u9875\u6267\u884c\u5165\u6808\uff0c\u8fd9\u6837\u6211\u4eec\u5c31\u53ef\u4ee5\u901a\u8fc7\u540e\u9000\u64cd\u4f5c\u56de\u5230\u4e0a\u4e00\u4e2a\u7f51\u9875\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\u4e0d\u65ad\u6267\u884c\u51fa\u6808\u64cd\u4f5c\u3002
    "},{"location":"chapter_stack_and_queue/summary/","title":"5.4 \u00a0 \u5c0f\u7ed3","text":""},{"location":"chapter_stack_and_queue/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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
    • \u5728\u65f6\u95f4\u6548\u7387\u65b9\u9762\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\u52a3\u5316\u81f3 \\(O(n)\\) \u3002\u76f8\u6bd4\u4e4b\u4e0b\uff0c\u6808\u7684\u94fe\u8868\u5b9e\u73b0\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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u5730\u5b9e\u73b0\u4e00\u4e9b\u989d\u5916\u64cd\u4f5c\uff0c\u8fd9\u4e2a\u5728\u201c\u53cc\u5411\u961f\u5217\u201d\u7ae0\u8282\u6709\u63d0\u5230\u3002

    Q\uff1a\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

    Q\uff1a\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\u6216\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

    Q\uff1a\u64a4\u9500\uff08undo\uff09\u548c\u53cd\u64a4\u9500\uff08redo\uff09\u5177\u4f53\u662f\u5982\u4f55\u5b9e\u73b0\u7684\uff1f

    \u4f7f\u7528\u4e24\u4e2a\u6808\uff0c\u6808 A \u7528\u4e8e\u64a4\u9500\uff0c\u6808 B \u7528\u4e8e\u53cd\u64a4\u9500\u3002

    1. \u6bcf\u5f53\u7528\u6237\u6267\u884c\u4e00\u4e2a\u64cd\u4f5c\uff0c\u5c06\u8fd9\u4e2a\u64cd\u4f5c\u538b\u5165\u6808 A \uff0c\u5e76\u6e05\u7a7a\u6808 B \u3002
    2. \u5f53\u7528\u6237\u6267\u884c\u201c\u64a4\u9500\u201d\u65f6\uff0c\u4ece\u6808 A \u4e2d\u5f39\u51fa\u6700\u8fd1\u7684\u64cd\u4f5c\uff0c\u5e76\u5c06\u5176\u538b\u5165\u6808 B \u3002
    3. \u5f53\u7528\u6237\u6267\u884c\u201c\u53cd\u64a4\u9500\u201d\u65f6\uff0c\u4ece\u6808 B \u4e2d\u5f39\u51fa\u6700\u8fd1\u7684\u64cd\u4f5c\uff0c\u5e76\u5c06\u5176\u538b\u5165\u6808 A \u3002
    "},{"location":"chapter_tree/","title":"\u7b2c 7 \u7ae0 \u00a0 \u6811","text":"

    Abstract

    \u53c2\u5929\u5927\u6811\u5145\u6ee1\u751f\u547d\u529b\uff0c\u6839\u6df1\u53f6\u8302\uff0c\u5206\u679d\u6276\u758f\u3002

    \u5b83\u4e3a\u6211\u4eec\u5c55\u73b0\u4e86\u6570\u636e\u5206\u6cbb\u7684\u751f\u52a8\u5f62\u6001\u3002

    "},{"location":"chapter_tree/#_1","title":"\u672c\u7ae0\u5185\u5bb9","text":"
    • 7.1 \u00a0 \u4e8c\u53c9\u6811
    • 7.2 \u00a0 \u4e8c\u53c9\u6811\u904d\u5386
    • 7.3 \u00a0 \u4e8c\u53c9\u6811\u6570\u7ec4\u8868\u793a
    • 7.4 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811
    • 7.5 \u00a0 AVL \u6811 *
    • 7.6 \u00a0 \u5c0f\u7ed3
    "},{"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\u4e0a\u4e00\u8282\u4ecb\u7ecd\u4e86\u94fe\u8868\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7684\u5404\u9879\u57fa\u672c\u64cd\u4f5c\u3002

    \u90a3\u4e48\uff0c\u6211\u4eec\u80fd\u5426\u7528\u6570\u7ec4\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\u3002\u7ed9\u5b9a\u4e00\u68f5\u5b8c\u7f8e\u4e8c\u53c9\u6811\uff0c\u6211\u4eec\u5c06\u6240\u6709\u8282\u70b9\u6309\u7167\u5c42\u5e8f\u904d\u5386\u7684\u987a\u5e8f\u5b58\u50a8\u5728\u4e00\u4e2a\u6570\u7ec4\u4e2d\uff0c\u5219\u6bcf\u4e2a\u8282\u70b9\u90fd\u5bf9\u5e94\u552f\u4e00\u7684\u6570\u7ec4\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\u67d0\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\u56fe 7-12 \u5c55\u793a\u4e86\u5404\u4e2a\u8282\u70b9\u7d22\u5f15\u4e4b\u95f4\u7684\u6620\u5c04\u5173\u7cfb\u3002

    \u56fe 7-12 \u00a0 \u5b8c\u7f8e\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    \u6620\u5c04\u516c\u5f0f\u7684\u89d2\u8272\u76f8\u5f53\u4e8e\u94fe\u8868\u4e2d\u7684\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\u3002\u7ed9\u5b9a\u6570\u7ec4\u4e2d\u7684\u4efb\u610f\u4e00\u4e2a\u8282\u70b9\uff0c\u6211\u4eec\u90fd\u53ef\u4ee5\u901a\u8fc7\u6620\u5c04\u516c\u5f0f\u6765\u8bbf\u95ee\u5b83\u7684\u5de6\uff08\u53f3\uff09\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":"

    \u5b8c\u7f8e\u4e8c\u53c9\u6811\u662f\u4e00\u4e2a\u7279\u4f8b\uff0c\u5728\u4e8c\u53c9\u6811\u7684\u4e2d\u95f4\u5c42\u901a\u5e38\u5b58\u5728\u8bb8\u591a None \u3002\u7531\u4e8e\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u5e76\u4e0d\u5305\u542b\u8fd9\u4e9b None \uff0c\u56e0\u6b64\u6211\u4eec\u65e0\u6cd5\u4ec5\u51ed\u8be5\u5e8f\u5217\u6765\u63a8\u6d4b None \u7684\u6570\u91cf\u548c\u5206\u5e03\u4f4d\u7f6e\u3002\u8fd9\u610f\u5473\u7740\u5b58\u5728\u591a\u79cd\u4e8c\u53c9\u6811\u7ed3\u6784\u90fd\u7b26\u5408\u8be5\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u3002

    \u5982\u56fe 7-13 \u6240\u793a\uff0c\u7ed9\u5b9a\u4e00\u68f5\u975e\u5b8c\u7f8e\u4e8c\u53c9\u6811\uff0c\u4e0a\u8ff0\u6570\u7ec4\u8868\u793a\u65b9\u6cd5\u5df2\u7ecf\u5931\u6548\u3002

    \u56fe 7-13 \u00a0 \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 None \u3002\u5982\u56fe 7-14 \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\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    # \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a\n# \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 int \u6700\u5927\u503c INT_MAX \u6807\u8bb0\u7a7a\u4f4d\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// \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? \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 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// \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
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \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// \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? \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
    /* \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a */\n// \u4f7f\u7528 None \u6765\u6807\u8bb0\u7a7a\u4f4d\nlet tree = [Some(1), Some(2), Some(3), Some(4), None, Some(6), Some(7), Some(8), Some(9), None, None, Some(12), None, None, Some(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 null \u6765\u8868\u793a\u7a7a\u4f4d\nval tree = mutableListOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )\n
    \n
    \n

    \u56fe 7-14 \u00a0 \u4efb\u610f\u7c7b\u578b\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    \u503c\u5f97\u8bf4\u660e\u7684\u662f\uff0c\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\uff0cNone \u53ea\u51fa\u73b0\u5728\u6700\u5e95\u5c42\u4e14\u9760\u53f3\u7684\u4f4d\u7f6e\uff0c\u56e0\u6b64\u6240\u6709 None \u4e00\u5b9a\u51fa\u73b0\u5728\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u7684\u672b\u5c3e\u3002

    \u8fd9\u610f\u5473\u7740\u4f7f\u7528\u6570\u7ec4\u8868\u793a\u5b8c\u5168\u4e8c\u53c9\u6811\u65f6\uff0c\u53ef\u4ee5\u7701\u7565\u5b58\u50a8\u6240\u6709 None \uff0c\u975e\u5e38\u65b9\u4fbf\u3002\u56fe 7-15 \u7ed9\u51fa\u4e86\u4e00\u4e2a\u4f8b\u5b50\u3002

    \u56fe 7-15 \u00a0 \u5b8c\u5168\u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a

    \u4ee5\u4e0b\u4ee3\u7801\u5b9e\u73b0\u4e86\u4e00\u68f5\u57fa\u4e8e\u6570\u7ec4\u8868\u793a\u7684\u4e8c\u53c9\u6811\uff0c\u5305\u62ec\u4ee5\u4e0b\u51e0\u79cd\u64cd\u4f5c\u3002

    • \u7ed9\u5b9a\u67d0\u8282\u70b9\uff0c\u83b7\u53d6\u5b83\u7684\u503c\u3001\u5de6\uff08\u53f3\uff09\u5b50\u8282\u70b9\u3001\u7236\u8282\u70b9\u3002
    • \u83b7\u53d6\u524d\u5e8f\u904d\u5386\u3001\u4e2d\u5e8f\u904d\u5386\u3001\u540e\u5e8f\u904d\u5386\u3001\u5c42\u5e8f\u904d\u5386\u5e8f\u5217\u3002
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig array_binary_tree.py
    class ArrayBinaryTree:\n    \"\"\"\u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b\"\"\"\n\n    def __init__(self, arr: list[int | None]):\n        \"\"\"\u6784\u9020\u65b9\u6cd5\"\"\"\n        self._tree = list(arr)\n\n    def size(self):\n        \"\"\"\u5217\u8868\u5bb9\u91cf\"\"\"\n        return len(self._tree)\n\n    def val(self, i: int) -> int:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c\"\"\"\n        # \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de None \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 or i >= self.size():\n            return None\n        return self._tree[i]\n\n    def left(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return 2 * i + 1\n\n    def right(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return 2 * i + 2\n\n    def parent(self, i: int) -> int | None:\n        \"\"\"\u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15\"\"\"\n        return (i - 1) // 2\n\n    def level_order(self) -> list[int]:\n        \"\"\"\u5c42\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        # \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in range(self.size()):\n            if self.val(i) is not None:\n                self.res.append(self.val(i))\n        return self.res\n\n    def dfs(self, i: int, order: str):\n        \"\"\"\u6df1\u5ea6\u4f18\u5148\u904d\u5386\"\"\"\n        if self.val(i) is None:\n            return\n        # \u524d\u5e8f\u904d\u5386\n        if order == \"pre\":\n            self.res.append(self.val(i))\n        self.dfs(self.left(i), order)\n        # \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\":\n            self.res.append(self.val(i))\n        self.dfs(self.right(i), order)\n        # \u540e\u5e8f\u904d\u5386\n        if order == \"post\":\n            self.res.append(self.val(i))\n\n    def pre_order(self) -> list[int]:\n        \"\"\"\u524d\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"pre\")\n        return self.res\n\n    def in_order(self) -> list[int]:\n        \"\"\"\u4e2d\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"in\")\n        return self.res\n\n    def post_order(self) -> list[int]:\n        \"\"\"\u540e\u5e8f\u904d\u5386\"\"\"\n        self.res = []\n        self.dfs(0, order=\"post\")\n        return self.res\n
    array_binary_tree.cpp
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n  public:\n    /* \u6784\u9020\u65b9\u6cd5 */\n    ArrayBinaryTree(vector<int> arr) {\n        tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    int size() {\n        return tree.size();\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    int val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de INT_MAX \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size())\n            return INT_MAX;\n        return tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    int left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    int right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    int parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    vector<int> levelOrder() {\n        vector<int> res;\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            if (val(i) != INT_MAX)\n                res.push_back(val(i));\n        }\n        return res;\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    vector<int> preOrder() {\n        vector<int> res;\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    vector<int> inOrder() {\n        vector<int> res;\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    vector<int> postOrder() {\n        vector<int> res;\n        dfs(0, \"post\", res);\n        return res;\n    }\n\n  private:\n    vector<int> tree;\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    void dfs(int i, string order, vector<int> &res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (val(i) == INT_MAX)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order == \"pre\")\n            res.push_back(val(i));\n        dfs(left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order == \"in\")\n            res.push_back(val(i));\n        dfs(right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order == \"post\")\n            res.push_back(val(i));\n    }\n};\n
    array_binary_tree.java
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    private List<Integer> tree;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    public ArrayBinaryTree(List<Integer> arr) {\n        tree = new ArrayList<>(arr);\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    public int size() {\n        return tree.size();\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    public Integer val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size())\n            return null;\n        return tree.get(i);\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    public Integer parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    public List<Integer> levelOrder() {\n        List<Integer> res = new ArrayList<>();\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < size(); i++) {\n            if (val(i) != null)\n                res.add(val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    private void dfs(Integer i, String order, List<Integer> res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (val(i) == null)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (\"pre\".equals(order))\n            res.add(val(i));\n        dfs(left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (\"in\".equals(order))\n            res.add(val(i));\n        dfs(right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (\"post\".equals(order))\n            res.add(val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    public List<Integer> preOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    public List<Integer> inOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    public List<Integer> postOrder() {\n        List<Integer> res = new ArrayList<>();\n        dfs(0, \"post\", res);\n        return res;\n    }\n}\n
    array_binary_tree.cs
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree(List<int?> arr) {\n    List<int?> tree = new(arr);\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    public int Size() {\n        return tree.Count;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    public int? Val(int i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= Size())\n            return null;\n        return tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Left(int i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Right(int i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    public int Parent(int i) {\n        return (i - 1) / 2;\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    public List<int> LevelOrder() {\n        List<int> res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (int i = 0; i < Size(); i++) {\n            if (Val(i).HasValue)\n                res.Add(Val(i)!.Value);\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    void DFS(int i, string order, List<int> res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (!Val(i).HasValue)\n            return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order == \"pre\")\n            res.Add(Val(i)!.Value);\n        DFS(Left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order == \"in\")\n            res.Add(Val(i)!.Value);\n        DFS(Right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order == \"post\")\n            res.Add(Val(i)!.Value);\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    public List<int> PreOrder() {\n        List<int> res = [];\n        DFS(0, \"pre\", res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    public List<int> InOrder() {\n        List<int> res = [];\n        DFS(0, \"in\", res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    public List<int> PostOrder() {\n        List<int> res = [];\n        DFS(0, \"post\", res);\n        return res;\n    }\n}\n
    array_binary_tree.go
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\ntype arrayBinaryTree struct {\n    tree []any\n}\n\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc newArrayBinaryTree(arr []any) *arrayBinaryTree {\n    return &arrayBinaryTree{\n        tree: arr,\n    }\n}\n\n/* \u5217\u8868\u5bb9\u91cf */\nfunc (abt *arrayBinaryTree) size() int {\n    return len(abt.tree)\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\nfunc (abt *arrayBinaryTree) val(i int) any {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if i < 0 || i >= abt.size() {\n        return nil\n    }\n    return abt.tree[i]\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) left(i int) int {\n    return 2*i + 1\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) right(i int) int {\n    return 2*i + 2\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\nfunc (abt *arrayBinaryTree) parent(i int) int {\n    return (i - 1) / 2\n}\n\n/* \u5c42\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) levelOrder() []any {\n    var res []any\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n    for i := 0; i < abt.size(); i++ {\n        if abt.val(i) != nil {\n            res = append(res, abt.val(i))\n        }\n    }\n    return res\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nfunc (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if abt.val(i) == nil {\n        return\n    }\n    // \u524d\u5e8f\u904d\u5386\n    if order == \"pre\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.left(i), order, res)\n    // \u4e2d\u5e8f\u904d\u5386\n    if order == \"in\" {\n        *res = append(*res, abt.val(i))\n    }\n    abt.dfs(abt.right(i), order, res)\n    // \u540e\u5e8f\u904d\u5386\n    if order == \"post\" {\n        *res = append(*res, abt.val(i))\n    }\n}\n\n/* \u524d\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) preOrder() []any {\n    var res []any\n    abt.dfs(0, \"pre\", &res)\n    return res\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) inOrder() []any {\n    var res []any\n    abt.dfs(0, \"in\", &res)\n    return res\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc (abt *arrayBinaryTree) postOrder() []any {\n    var res []any\n    abt.dfs(0, \"post\", &res)\n    return res\n}\n
    array_binary_tree.swift
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    private var tree: [Int?]\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    init(arr: [Int?]) {\n        tree = arr\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    func size() -> Int {\n        tree.count\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    func val(i: Int) -> Int? {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 || i >= size() {\n            return nil\n        }\n        return tree[i]\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    func left(i: Int) -> Int {\n        2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    func right(i: Int) -> Int {\n        2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    func parent(i: Int) -> Int {\n        (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    func levelOrder() -> [Int] {\n        var res: [Int] = []\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in 0 ..< size() {\n            if let val = val(i: i) {\n                res.append(val)\n            }\n        }\n        return res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    private func dfs(i: Int, order: String, res: inout [Int]) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        guard let val = val(i: i) else {\n            return\n        }\n        // \u524d\u5e8f\u904d\u5386\n        if order == \"pre\" {\n            res.append(val)\n        }\n        dfs(i: left(i: i), order: order, res: &res)\n        // \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\" {\n            res.append(val)\n        }\n        dfs(i: right(i: i), order: order, res: &res)\n        // \u540e\u5e8f\u904d\u5386\n        if order == \"post\" {\n            res.append(val)\n        }\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    func preOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"pre\", res: &res)\n        return res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    func inOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"in\", res: &res)\n        return res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    func postOrder() -> [Int] {\n        var res: [Int] = []\n        dfs(i: 0, order: \"post\", res: &res)\n        return res\n    }\n}\n
    array_binary_tree.js
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    #tree;\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(arr) {\n        this.#tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    size() {\n        return this.#tree.length;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    val(i) {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    left(i) {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    right(i) {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    parent(i) {\n        return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    levelOrder() {\n        let res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (let i = 0; i < this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    #dfs(i, order, res) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (this.val(i) === null) return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    preOrder() {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    inOrder() {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    postOrder() {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n
    array_binary_tree.ts
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n    #tree: (number | null)[];\n\n    /* \u6784\u9020\u65b9\u6cd5 */\n    constructor(arr: (number | null)[]) {\n        this.#tree = arr;\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    size(): number {\n        return this.#tree.length;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    val(i: number): number | null {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= this.size()) return null;\n        return this.#tree[i];\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    left(i: number): number {\n        return 2 * i + 1;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    right(i: number): number {\n        return 2 * i + 2;\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    parent(i: number): number {\n        return Math.floor((i - 1) / 2); // \u5411\u4e0b\u6574\u9664\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    levelOrder(): number[] {\n        let res = [];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (let i = 0; i < this.size(); i++) {\n            if (this.val(i) !== null) res.push(this.val(i));\n        }\n        return res;\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    #dfs(i: number, order: Order, res: (number | null)[]): void {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (this.val(i) === null) return;\n        // \u524d\u5e8f\u904d\u5386\n        if (order === 'pre') res.push(this.val(i));\n        this.#dfs(this.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if (order === 'in') res.push(this.val(i));\n        this.#dfs(this.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if (order === 'post') res.push(this.val(i));\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    preOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'pre', res);\n        return res;\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    inOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'in', res);\n        return res;\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    postOrder(): (number | null)[] {\n        const res = [];\n        this.#dfs(0, 'post', res);\n        return res;\n    }\n}\n
    array_binary_tree.dart
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree {\n  late List<int?> _tree;\n\n  /* \u6784\u9020\u65b9\u6cd5 */\n  ArrayBinaryTree(this._tree);\n\n  /* \u5217\u8868\u5bb9\u91cf */\n  int size() {\n    return _tree.length;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n  int? val(int i) {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if (i < 0 || i >= size()) {\n      return null;\n    }\n    return _tree[i];\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? left(int i) {\n    return 2 * i + 1;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? right(int i) {\n    return 2 * i + 2;\n  }\n\n  /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n  int? parent(int i) {\n    return (i - 1) ~/ 2;\n  }\n\n  /* \u5c42\u5e8f\u904d\u5386 */\n  List<int> levelOrder() {\n    List<int> res = [];\n    for (int i = 0; i < size(); i++) {\n      if (val(i) != null) {\n        res.add(val(i)!);\n      }\n    }\n    return res;\n  }\n\n  /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n  void dfs(int i, String order, List<int?> res) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if (val(i) == null) {\n      return;\n    }\n    // \u524d\u5e8f\u904d\u5386\n    if (order == 'pre') {\n      res.add(val(i));\n    }\n    dfs(left(i)!, order, res);\n    // \u4e2d\u5e8f\u904d\u5386\n    if (order == 'in') {\n      res.add(val(i));\n    }\n    dfs(right(i)!, order, res);\n    // \u540e\u5e8f\u904d\u5386\n    if (order == 'post') {\n      res.add(val(i));\n    }\n  }\n\n  /* \u524d\u5e8f\u904d\u5386 */\n  List<int?> preOrder() {\n    List<int?> res = [];\n    dfs(0, 'pre', res);\n    return res;\n  }\n\n  /* \u4e2d\u5e8f\u904d\u5386 */\n  List<int?> inOrder() {\n    List<int?> res = [];\n    dfs(0, 'in', res);\n    return res;\n  }\n\n  /* \u540e\u5e8f\u904d\u5386 */\n  List<int?> postOrder() {\n    List<int?> res = [];\n    dfs(0, 'post', res);\n    return res;\n  }\n}\n
    array_binary_tree.rs
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nstruct ArrayBinaryTree {\n    tree: Vec<Option<i32>>,\n}\n\nimpl ArrayBinaryTree {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(arr: Vec<Option<i32>>) -> Self {\n        Self { tree: arr }\n    }\n\n    /* \u5217\u8868\u5bb9\u91cf */\n    fn size(&self) -> i32 {\n        self.tree.len() as i32\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    fn val(&self, i: i32) -> Option<i32> {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de None \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if i < 0 || i >= self.size() {\n            None\n        } else {\n            self.tree[i as usize]\n        }\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn left(&self, i: i32) -> i32 {\n        2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn right(&self, i: i32) -> i32 {\n        2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    fn parent(&self, i: i32) -> i32 {\n        (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    fn level_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for i in 0..self.size() {\n            if let Some(val) = self.val(i) {\n                res.push(val)\n            }\n        }\n        res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    fn dfs(&self, i: i32, order: &str, res: &mut Vec<i32>) {\n        if self.val(i).is_none() {\n            return;\n        }\n        let val = self.val(i).unwrap();\n        // \u524d\u5e8f\u904d\u5386\n        if order == \"pre\" {\n            res.push(val);\n        }\n        self.dfs(self.left(i), order, res);\n        // \u4e2d\u5e8f\u904d\u5386\n        if order == \"in\" {\n            res.push(val);\n        }\n        self.dfs(self.right(i), order, res);\n        // \u540e\u5e8f\u904d\u5386\n        if order == \"post\" {\n            res.push(val);\n        }\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    fn pre_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"pre\", &mut res);\n        res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    fn in_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"in\", &mut res);\n        res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    fn post_order(&self) -> Vec<i32> {\n        let mut res = vec![];\n        self.dfs(0, \"post\", &mut res);\n        res\n    }\n}\n
    array_binary_tree.c
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7ed3\u6784\u4f53 */\ntypedef struct {\n    int *tree;\n    int size;\n} ArrayBinaryTree;\n\n/* \u6784\u9020\u51fd\u6570 */\nArrayBinaryTree *newArrayBinaryTree(int *arr, int arrSize) {\n    ArrayBinaryTree *abt = (ArrayBinaryTree *)malloc(sizeof(ArrayBinaryTree));\n    abt->tree = malloc(sizeof(int) * arrSize);\n    memcpy(abt->tree, arr, sizeof(int) * arrSize);\n    abt->size = arrSize;\n    return abt;\n}\n\n/* \u6790\u6784\u51fd\u6570 */\nvoid delArrayBinaryTree(ArrayBinaryTree *abt) {\n    free(abt->tree);\n    free(abt);\n}\n\n/* \u5217\u8868\u5bb9\u91cf */\nint size(ArrayBinaryTree *abt) {\n    return abt->size;\n}\n\n/* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\nint val(ArrayBinaryTree *abt, int i) {\n    // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de INT_MAX \uff0c\u4ee3\u8868\u7a7a\u4f4d\n    if (i < 0 || i >= size(abt))\n        return INT_MAX;\n    return abt->tree[i];\n}\n\n/* \u5c42\u5e8f\u904d\u5386 */\nint *levelOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n    for (int i = 0; i < size(abt); i++) {\n        if (val(abt, i) != INT_MAX)\n            res[index++] = val(abt, i);\n    }\n    *returnSize = index;\n    return res;\n}\n\n/* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\nvoid dfs(ArrayBinaryTree *abt, int i, char *order, int *res, int *index) {\n    // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n    if (val(abt, i) == INT_MAX)\n        return;\n    // \u524d\u5e8f\u904d\u5386\n    if (strcmp(order, \"pre\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, left(i), order, res, index);\n    // \u4e2d\u5e8f\u904d\u5386\n    if (strcmp(order, \"in\") == 0)\n        res[(*index)++] = val(abt, i);\n    dfs(abt, right(i), order, res, index);\n    // \u540e\u5e8f\u904d\u5386\n    if (strcmp(order, \"post\") == 0)\n        res[(*index)++] = val(abt, i);\n}\n\n/* \u524d\u5e8f\u904d\u5386 */\nint *preOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"pre\", res, &index);\n    *returnSize = index;\n    return res;\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nint *inOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"in\", res, &index);\n    *returnSize = index;\n    return res;\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nint *postOrder(ArrayBinaryTree *abt, int *returnSize) {\n    int *res = (int *)malloc(sizeof(int) * size(abt));\n    int index = 0;\n    dfs(abt, 0, \"post\", res, &index);\n    *returnSize = index;\n    return res;\n}\n
    array_binary_tree.kt
    /* \u6570\u7ec4\u8868\u793a\u4e0b\u7684\u4e8c\u53c9\u6811\u7c7b */\nclass ArrayBinaryTree(val tree: List<Int?>) {\n    /* \u5217\u8868\u5bb9\u91cf */\n    fun size(): Int {\n        return tree.size\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u503c */\n    fun value(i: Int): Int? {\n        // \u82e5\u7d22\u5f15\u8d8a\u754c\uff0c\u5219\u8fd4\u56de null \uff0c\u4ee3\u8868\u7a7a\u4f4d\n        if (i < 0 || i >= size()) return null\n        return tree[i]\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u5de6\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun left(i: Int): Int {\n        return 2 * i + 1\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u53f3\u5b50\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun right(i: Int): Int {\n        return 2 * i + 2\n    }\n\n    /* \u83b7\u53d6\u7d22\u5f15\u4e3a i \u8282\u70b9\u7684\u7236\u8282\u70b9\u7684\u7d22\u5f15 */\n    fun parent(i: Int): Int {\n        return (i - 1) / 2\n    }\n\n    /* \u5c42\u5e8f\u904d\u5386 */\n    fun levelOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        // \u76f4\u63a5\u904d\u5386\u6570\u7ec4\n        for (i in 0..<size()) {\n            if (value(i) != null) res.add(value(i))\n        }\n        return res\n    }\n\n    /* \u6df1\u5ea6\u4f18\u5148\u904d\u5386 */\n    fun dfs(i: Int, order: String, res: MutableList<Int?>) {\n        // \u82e5\u4e3a\u7a7a\u4f4d\uff0c\u5219\u8fd4\u56de\n        if (value(i) == null) return\n        // \u524d\u5e8f\u904d\u5386\n        if (\"pre\" == order) res.add(value(i))\n        dfs(left(i), order, res)\n        // \u4e2d\u5e8f\u904d\u5386\n        if (\"in\" == order) res.add(value(i))\n        dfs(right(i), order, res)\n        // \u540e\u5e8f\u904d\u5386\n        if (\"post\" == order) res.add(value(i))\n    }\n\n    /* \u524d\u5e8f\u904d\u5386 */\n    fun preOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"pre\", res)\n        return res\n    }\n\n    /* \u4e2d\u5e8f\u904d\u5386 */\n    fun inOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"in\", res)\n        return res\n    }\n\n    /* \u540e\u5e8f\u904d\u5386 */\n    fun postOrder(): List<Int?> {\n        val res = ArrayList<Int?>()\n        dfs(0, \"post\", res)\n        return res\n    }\n}\n
    array_binary_tree.rb
    [class]{ArrayBinaryTree}-[func]{}\n
    array_binary_tree.zig
    [class]{ArrayBinaryTree}-[func]{}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/array_representation_of_tree/#733","title":"7.3.3 \u00a0 \u4f18\u70b9\u4e0e\u5c40\u9650\u6027","text":"

    \u4e8c\u53c9\u6811\u7684\u6570\u7ec4\u8868\u793a\u4e3b\u8981\u6709\u4ee5\u4e0b\u4f18\u70b9\u3002

    • \u6570\u7ec4\u5b58\u50a8\u5728\u8fde\u7eed\u7684\u5185\u5b58\u7a7a\u95f4\u4e2d\uff0c\u5bf9\u7f13\u5b58\u53cb\u597d\uff0c\u8bbf\u95ee\u4e0e\u904d\u5386\u901f\u5ea6\u8f83\u5feb\u3002
    • \u4e0d\u9700\u8981\u5b58\u50a8\u6307\u9488\uff0c\u6bd4\u8f83\u8282\u7701\u7a7a\u95f4\u3002
    • \u5141\u8bb8\u968f\u673a\u8bbf\u95ee\u8282\u70b9\u3002

    \u7136\u800c\uff0c\u6570\u7ec4\u8868\u793a\u4e5f\u5b58\u5728\u4e00\u4e9b\u5c40\u9650\u6027\u3002

    • \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\u3002
    • \u5f53\u4e8c\u53c9\u6811\u4e2d\u5b58\u5728\u5927\u91cf 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
    "},{"location":"chapter_tree/avl_tree/","title":"7.5 \u00a0 AVL \u6811 *","text":"

    \u5728\u201c\u4e8c\u53c9\u641c\u7d22\u6811\u201d\u7ae0\u8282\u4e2d\u6211\u4eec\u63d0\u5230\uff0c\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\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6240\u6709\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u5c06\u4ece \\(O(\\log n)\\) \u52a3\u5316\u4e3a \\(O(n)\\) \u3002

    \u5982\u56fe 7-24 \u6240\u793a\uff0c\u7ecf\u8fc7\u4e24\u6b21\u5220\u9664\u8282\u70b9\u64cd\u4f5c\uff0c\u8fd9\u68f5\u4e8c\u53c9\u641c\u7d22\u6811\u4fbf\u4f1a\u9000\u5316\u4e3a\u94fe\u8868\u3002

    \u56fe 7-24 \u00a0 AVL \u6811\u5728\u5220\u9664\u8282\u70b9\u540e\u53d1\u751f\u9000\u5316

    \u518d\u4f8b\u5982\uff0c\u5728\u56fe 7-25 \u6240\u793a\u7684\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\u52a3\u5316\u3002

    \u56fe 7-25 \u00a0 AVL \u6811\u5728\u63d2\u5165\u8282\u70b9\u540e\u53d1\u751f\u9000\u5316

    1962 \u5e74 G. M. Adelson-Velsky \u548c E. M. Landis \u5728\u8bba\u6587\u201cAn algorithm for the organization of information\u201d\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":"

    AVL \u6811\u65e2\u662f\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\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\u662f\u4e00\u79cd\u300c\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811 balanced binary search tree\u300d\u3002

    "},{"location":"chapter_tree/avl_tree/#1","title":"1. \u00a0 \u8282\u70b9\u9ad8\u5ea6","text":"

    \u7531\u4e8e AVL \u6811\u7684\u76f8\u5173\u64cd\u4f5c\u9700\u8981\u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6\uff0c\u56e0\u6b64\u6211\u4eec\u9700\u8981\u4e3a\u8282\u70b9\u7c7b\u6dfb\u52a0 height \u53d8\u91cf\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class TreeNode:\n    \"\"\"AVL \u6811\u8282\u70b9\u7c7b\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                 # \u8282\u70b9\u503c\n        self.height: int = 0                # \u8282\u70b9\u9ad8\u5ea6\n        self.left: TreeNode | None = None   # \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n        self.right: TreeNode | None = None  # \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nstruct TreeNode {\n    int val{};          // \u8282\u70b9\u503c\n    int height = 0;     // \u8282\u70b9\u9ad8\u5ea6\n    TreeNode *left{};   // \u5de6\u5b50\u8282\u70b9\n    TreeNode *right{};  // \u53f3\u5b50\u8282\u70b9\n    TreeNode() = default;\n    explicit TreeNode(int x) : val(x){}\n};\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    public int val;        // \u8282\u70b9\u503c\n    public int height;     // \u8282\u70b9\u9ad8\u5ea6\n    public TreeNode left;  // \u5de6\u5b50\u8282\u70b9\n    public TreeNode right; // \u53f3\u5b50\u8282\u70b9\n    public TreeNode(int x) { val = x; }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode(int? x) {\n    public int? val = x;    // \u8282\u70b9\u503c\n    public int height;      // \u8282\u70b9\u9ad8\u5ea6\n    public TreeNode? left;  // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    public TreeNode? right; // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    /* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype TreeNode struct {\n    Val    int       // \u8282\u70b9\u503c\n    Height int       // \u8282\u70b9\u9ad8\u5ea6\n    Left   *TreeNode // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    Right  *TreeNode // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    var val: Int // \u8282\u70b9\u503c\n    var height: Int // \u8282\u70b9\u9ad8\u5ea6\n    var left: TreeNode? // \u5de6\u5b50\u8282\u70b9\n    var right: TreeNode? // \u53f3\u5b50\u8282\u70b9\n\n    init(x: Int) {\n        val = x\n        height = 0\n    }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    val; // \u8282\u70b9\u503c\n    height; //\u8282\u70b9\u9ad8\u5ea6\n    left; // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n    constructor(val, left, right, height) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    val: number;            // \u8282\u70b9\u503c\n    height: number;         // \u8282\u70b9\u9ad8\u5ea6\n    left: TreeNode | null;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    right: TreeNode | null; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n    constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val;\n        this.height = height === undefined ? 0 : height; \n        this.left = left === undefined ? null : left; \n        this.right = right === undefined ? null : right; \n    }\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n  int val;         // \u8282\u70b9\u503c\n  int height;      // \u8282\u70b9\u9ad8\u5ea6\n  TreeNode? left;  // \u5de6\u5b50\u8282\u70b9\n  TreeNode? right; // \u53f3\u5b50\u8282\u70b9\n  TreeNode(this.val, [this.height = 0, this.left, this.right]);\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\n    val: i32,                               // \u8282\u70b9\u503c\n    height: i32,                            // \u8282\u70b9\u9ad8\u5ea6\n    left: Option<Rc<RefCell<TreeNode>>>,    // \u5de6\u5b50\u8282\u70b9\n    right: Option<Rc<RefCell<TreeNode>>>,   // \u53f3\u5b50\u8282\u70b9\n}\n\nimpl TreeNode {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(val: i32) -> Rc<RefCell<Self>> {\n        Rc::new(RefCell::new(Self {\n            val,\n            height: 0,\n            left: None,\n            right: None\n        }))\n    }\n}\n
    /* AVL \u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nTreeNode struct TreeNode {\n    int val;\n    int height;\n    struct TreeNode *left;\n    struct TreeNode *right;\n} TreeNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node->val = val;\n    node->height = 0;\n    node->left = NULL;\n    node->right = NULL;\n    return node;\n}\n
    /* AVL \u6811\u8282\u70b9\u7c7b */\nclass TreeNode(val _val: Int) {  // \u8282\u70b9\u503c\n    val height: Int = 0          // \u8282\u70b9\u9ad8\u5ea6\n    val left: TreeNode? = null   // \u5de6\u5b50\u8282\u70b9\n    val right: TreeNode? = null  // \u53f3\u5b50\u8282\u70b9\n}\n
    \n
    \n

    \u201c\u8282\u70b9\u9ad8\u5ea6\u201d\u662f\u6307\u4ece\u8be5\u8282\u70b9\u5230\u5b83\u7684\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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if node is not None:\n        return node.height\n    return -1\n\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\n    node.height = max([self.height(node.left), self.height(node.right)]) + 1\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\n    return node == nullptr ? -1 : node->height;\n}\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\n    node->height = max(height(node->left), height(node->right)) + 1;\n}\n
    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\n    return node == null ? -1 : node.height;\n}\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\n    node.height = Math.max(height(node.left), height(node.right)) + 1;\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\n    return node == null ? -1 : node.height;\n}\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\n    node.height = Math.Max(Height(node.left), Height(node.right)) + 1;\n}\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\n    if node != nil {\n        return node.Height\n    }\n    return -1\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfunc (t *aVLTree) updateHeight(node *TreeNode) {\n    lh := t.height(node.Left)\n    rh := t.height(node.Right)\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    if lh > rh {\n        node.Height = lh + 1\n    } else {\n        node.Height = rh + 1\n    }\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\n    node?.height ?? -1\n}\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\n    node?.height = max(height(node: node?.left), height(node: node?.right)) + 1\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\n    return node === null ? -1 : node.height;\n}\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\n    node.height =\n        Math.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\n    return node === null ? -1 : node.height;\n}\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\n    node.height =\n        Math.max(this.height(node.left), this.height(node.right)) + 1;\n}\n
    avl_tree.dart
    /* \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\n  return node == null ? -1 : node.height;\n}\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\n  node!.height = max(height(node.left), height(node.right)) + 1;\n}\n
    avl_tree.rs
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfn height(node: OptionTreeNodeRc) -> i32 {\n    // \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\n    match node {\n        Some(node) => node.borrow().height,\n        None => -1,\n    }\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfn update_height(node: OptionTreeNodeRc) {\n    if let Some(node) = node {\n        let left = node.borrow().left.clone();\n        let right = node.borrow().right.clone();\n        // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n        node.borrow_mut().height = std::cmp::max(Self::height(left), Self::height(right)) + 1;\n    }\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\n    if (node != NULL) {\n        return node->height;\n    }\n    return -1;\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nvoid updateHeight(TreeNode *node) {\n    int lh = height(node->left);\n    int rh = height(node->right);\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    if (lh > rh) {\n        node->height = lh + 1;\n    } else {\n        node->height = rh + 1;\n    }\n}\n
    avl_tree.kt
    /* \u83b7\u53d6\u8282\u70b9\u9ad8\u5ea6 */\nfun height(node: TreeNode?): Int {\n    // \u7a7a\u8282\u70b9\u9ad8\u5ea6\u4e3a -1 \uff0c\u53f6\u8282\u70b9\u9ad8\u5ea6\u4e3a 0\n    return node?.height ?: -1\n}\n\n/* \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6 */\nfun updateHeight(node: TreeNode?) {\n    // \u8282\u70b9\u9ad8\u5ea6\u7b49\u4e8e\u6700\u9ad8\u5b50\u6811\u9ad8\u5ea6 + 1\n    node?.height = (max(height(node?.left).toDouble(), height(node?.right).toDouble()) + 1).toInt()\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{height}\n\n[class]{AVLTree}-[func]{update_height}\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\n    return if (node == null) -1 else node.?.height;\n}\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\n    node.?.height = @max(self.height(node.?.left), self.height(node.?.right)) + 1;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2","title":"2. \u00a0 \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    if node is None:\n        return 0\n    # \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return self.height(node.left) - self.height(node.right)\n
    avl_tree.cpp
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode *node) {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == nullptr)\n        return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node->left) - height(node->right);\n}\n
    avl_tree.java
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nint balanceFactor(TreeNode node) {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == null)\n        return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return 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\n    if (node == null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return Height(node.left) - Height(node.right);\n}\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\n    if node == nil {\n        return 0\n    }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return t.height(node.Left) - t.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\n    guard let node = node else { return 0 }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node: node.left) - height(node: 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\n    if (node === null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return 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\n    if (node === null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return this.height(node.left) - this.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\n  if (node == null) return 0;\n  // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n  return height(node.left) - height(node.right);\n}\n
    avl_tree.rs
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfn balance_factor(node: OptionTreeNodeRc) -> i32 {\n    match node {\n        // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n        None => 0,\n        // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n        Some(node) => {\n            Self::height(node.borrow().left.clone()) - Self::height(node.borrow().right.clone())\n        }\n    }\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\n    if (node == NULL) {\n        return 0;\n    }\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node->left) - height(node->right);\n}\n
    avl_tree.kt
    /* \u83b7\u53d6\u5e73\u8861\u56e0\u5b50 */\nfun balanceFactor(node: TreeNode?): Int {\n    // \u7a7a\u8282\u70b9\u5e73\u8861\u56e0\u5b50\u4e3a 0\n    if (node == null) return 0\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return height(node.left) - height(node.right)\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{balance_factor}\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\n    if (node == null) return 0;\n    // \u8282\u70b9\u5e73\u8861\u56e0\u5b50 = \u5de6\u5b50\u6811\u9ad8\u5ea6 - \u53f3\u5b50\u6811\u9ad8\u5ea6\n    return self.height(node.?.left) - self.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\u201c\u65cb\u8f6c\u201d\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\u201c\u4e8c\u53c9\u641c\u7d22\u6811\u201d\u7684\u6027\u8d28\uff0c\u4e5f\u80fd\u4f7f\u6811\u91cd\u65b0\u53d8\u4e3a\u201c\u5e73\u8861\u4e8c\u53c9\u6811\u201d\u3002

    \u6211\u4eec\u5c06\u5e73\u8861\u56e0\u5b50\u7edd\u5bf9\u503c \\(> 1\\) \u7684\u8282\u70b9\u79f0\u4e3a\u201c\u5931\u8861\u8282\u70b9\u201d\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\u8be6\u7ec6\u4ecb\u7ecd\u8fd9\u4e9b\u65cb\u8f6c\u64cd\u4f5c\u3002

    "},{"location":"chapter_tree/avl_tree/#1_1","title":"1. \u00a0 \u53f3\u65cb","text":"

    \u5982\u56fe 7-26 \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\u201c\u53f3\u65cb\u201d\u64cd\u4f5c\u3002\u5b8c\u6210\u53f3\u65cb\u540e\uff0c\u5b50\u6811\u6062\u590d\u5e73\u8861\uff0c\u5e76\u4e14\u4ecd\u7136\u4fdd\u6301\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6027\u8d28\u3002

    <1><2><3><4>

    \u56fe 7-26 \u00a0 \u53f3\u65cb\u64cd\u4f5c\u6b65\u9aa4

    \u5982\u56fe 7-27 \u6240\u793a\uff0c\u5f53\u8282\u70b9 child \u6709\u53f3\u5b50\u8282\u70b9\uff08\u8bb0\u4e3a grand_child \uff09\u65f6\uff0c\u9700\u8981\u5728\u53f3\u65cb\u4e2d\u6dfb\u52a0\u4e00\u6b65\uff1a\u5c06 grand_child \u4f5c\u4e3a node \u7684\u5de6\u5b50\u8282\u70b9\u3002

    \u56fe 7-27 \u00a0 \u6709 grand_child \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\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def right_rotate(self, node: TreeNode | None) -> TreeNode | None:\n    \"\"\"\u53f3\u65cb\u64cd\u4f5c\"\"\"\n    child = node.left\n    grand_child = child.right\n    # \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node\n    node.left = grand_child\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    self.update_height(child)\n    # \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n
    avl_tree.cpp
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child = node->left;\n    TreeNode *grandChild = child->right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child->right = node;\n    node->left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.java
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode rightRotate(TreeNode node) {\n    TreeNode child = node.left;\n    TreeNode grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.cs
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? RightRotate(TreeNode? node) {\n    TreeNode? child = node?.left;\n    TreeNode? grandChild = child?.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.go
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) rightRotate(node *TreeNode) *TreeNode {\n    child := node.Left\n    grandChild := child.Right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.Right = node\n    node.Left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.swift
    /* \u53f3\u65cb\u64cd\u4f5c */\nfunc rightRotate(node: TreeNode?) -> TreeNode? {\n    let child = node?.left\n    let grandChild = child?.right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child?.right = node\n    node?.left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.js
    /* \u53f3\u65cb\u64cd\u4f5c */\n#rightRotate(node) {\n    const child = node.left;\n    const grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.ts
    /* \u53f3\u65cb\u64cd\u4f5c */\nrightRotate(node: TreeNode): TreeNode {\n    const child = node.left;\n    const grandChild = child.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node;\n    node.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.dart
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode? rightRotate(TreeNode? node) {\n  TreeNode? child = node!.left;\n  TreeNode? grandChild = child!.right;\n  // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n  child.right = node;\n  node.left = grandChild;\n  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n  updateHeight(node);\n  updateHeight(child);\n  // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return child;\n}\n
    avl_tree.rs
    /* \u53f3\u65cb\u64cd\u4f5c */\nfn right_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    match node {\n        Some(node) => {\n            let child = node.borrow().left.clone().unwrap();\n            let grand_child = child.borrow().right.clone();\n            // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n            child.borrow_mut().right = Some(node.clone());\n            node.borrow_mut().left = grand_child;\n            // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(child)\n        }\n        None => None,\n    }\n}\n
    avl_tree.c
    /* \u53f3\u65cb\u64cd\u4f5c */\nTreeNode *rightRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node->left;\n    grandChild = child->right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child->right = node;\n    node->left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.kt
    /* \u53f3\u65cb\u64cd\u4f5c */\nfun rightRotate(node: TreeNode?): TreeNode {\n    val child = node!!.left\n    val grandChild = child!!.right\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.right = node\n    node.left = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node)\n    updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{right_rotate}\n
    avl_tree.zig
    // \u53f3\u65cb\u64cd\u4f5c\nfn rightRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\n    var child = node.?.left;\n    var grandChild = child.?.right;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u53f3\u65cb\u8f6c\n    child.?.right = node;\n    node.?.left = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.updateHeight(node);\n    self.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2_1","title":"2. \u00a0 \u5de6\u65cb","text":"

    \u76f8\u5e94\u5730\uff0c\u5982\u679c\u8003\u8651\u4e0a\u8ff0\u5931\u8861\u4e8c\u53c9\u6811\u7684\u201c\u955c\u50cf\u201d\uff0c\u5219\u9700\u8981\u6267\u884c\u56fe 7-28 \u6240\u793a\u7684\u201c\u5de6\u65cb\u201d\u64cd\u4f5c\u3002

    \u56fe 7-28 \u00a0 \u5de6\u65cb\u64cd\u4f5c

    \u540c\u7406\uff0c\u5982\u56fe 7-29 \u6240\u793a\uff0c\u5f53\u8282\u70b9 child \u6709\u5de6\u5b50\u8282\u70b9\uff08\u8bb0\u4e3a grand_child \uff09\u65f6\uff0c\u9700\u8981\u5728\u5de6\u65cb\u4e2d\u6dfb\u52a0\u4e00\u6b65\uff1a\u5c06 grand_child \u4f5c\u4e3a node \u7684\u53f3\u5b50\u8282\u70b9\u3002

    \u56fe 7-29 \u00a0 \u6709 grand_child \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\u53ea\u9700\u5c06\u53f3\u65cb\u7684\u5b9e\u73b0\u4ee3\u7801\u4e2d\u7684\u6240\u6709\u7684 left \u66ff\u6362\u4e3a right \uff0c\u5c06\u6240\u6709\u7684 right \u66ff\u6362\u4e3a left \uff0c\u5373\u53ef\u5f97\u5230\u5de6\u65cb\u7684\u5b9e\u73b0\u4ee3\u7801\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def left_rotate(self, node: TreeNode | None) -> TreeNode | None:\n    \"\"\"\u5de6\u65cb\u64cd\u4f5c\"\"\"\n    child = node.right\n    grand_child = child.left\n    # \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node\n    node.right = grand_child\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    self.update_height(child)\n    # \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n
    avl_tree.cpp
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child = node->right;\n    TreeNode *grandChild = child->left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child->left = node;\n    node->right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.java
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode leftRotate(TreeNode node) {\n    TreeNode child = node.right;\n    TreeNode grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.cs
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? LeftRotate(TreeNode? node) {\n    TreeNode? child = node?.right;\n    TreeNode? grandChild = child?.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    UpdateHeight(node);\n    UpdateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.go
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc (t *aVLTree) leftRotate(node *TreeNode) *TreeNode {\n    child := node.Right\n    grandChild := child.Left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.Left = node\n    node.Right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    t.updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.swift
    /* \u5de6\u65cb\u64cd\u4f5c */\nfunc leftRotate(node: TreeNode?) -> TreeNode? {\n    let child = node?.right\n    let grandChild = child?.left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child?.left = node\n    node?.right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node: node)\n    updateHeight(node: child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.js
    /* \u5de6\u65cb\u64cd\u4f5c */\n#leftRotate(node) {\n    const child = node.right;\n    const grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.#updateHeight(node);\n    this.#updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.ts
    /* \u5de6\u65cb\u64cd\u4f5c */\nleftRotate(node: TreeNode): TreeNode {\n    const child = node.right;\n    const grandChild = child.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node;\n    node.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    this.updateHeight(node);\n    this.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.dart
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode? leftRotate(TreeNode? node) {\n  TreeNode? child = node!.right;\n  TreeNode? grandChild = child!.left;\n  // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n  child.left = node;\n  node.right = grandChild;\n  // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n  updateHeight(node);\n  updateHeight(child);\n  // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return child;\n}\n
    avl_tree.rs
    /* \u5de6\u65cb\u64cd\u4f5c */\nfn left_rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    match node {\n        Some(node) => {\n            let child = node.borrow().right.clone().unwrap();\n            let grand_child = child.borrow().left.clone();\n            // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n            child.borrow_mut().left = Some(node.clone());\n            node.borrow_mut().right = grand_child;\n            // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n            Self::update_height(Some(node));\n            Self::update_height(Some(child.clone()));\n            // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(child)\n        }\n        None => None,\n    }\n}\n
    avl_tree.c
    /* \u5de6\u65cb\u64cd\u4f5c */\nTreeNode *leftRotate(TreeNode *node) {\n    TreeNode *child, *grandChild;\n    child = node->right;\n    grandChild = child->left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child->left = node;\n    node->right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    avl_tree.kt
    /* \u5de6\u65cb\u64cd\u4f5c */\nfun leftRotate(node: TreeNode?): TreeNode {\n    val child = node!!.right\n    val grandChild = child!!.left\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.left = node\n    node.right = grandChild\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node)\n    updateHeight(child)\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{left_rotate}\n
    avl_tree.zig
    // \u5de6\u65cb\u64cd\u4f5c\nfn leftRotate(self: *Self, node: ?*inc.TreeNode(T)) ?*inc.TreeNode(T) {\n    var child = node.?.right;\n    var grandChild = child.?.left;\n    // \u4ee5 child \u4e3a\u539f\u70b9\uff0c\u5c06 node \u5411\u5de6\u65cb\u8f6c\n    child.?.left = node;\n    node.?.right = grandChild;\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.updateHeight(node);\n    self.updateHeight(child);\n    // \u8fd4\u56de\u65cb\u8f6c\u540e\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return child;\n}\n
    "},{"location":"chapter_tree/avl_tree/#3","title":"3. \u00a0 \u5148\u5de6\u65cb\u540e\u53f3\u65cb","text":"

    \u5bf9\u4e8e\u56fe 7-30 \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\u5bf9 child \u6267\u884c\u201c\u5de6\u65cb\u201d\uff0c\u518d\u5bf9 node \u6267\u884c\u201c\u53f3\u65cb\u201d\u3002

    \u56fe 7-30 \u00a0 \u5148\u5de6\u65cb\u540e\u53f3\u65cb

    "},{"location":"chapter_tree/avl_tree/#4","title":"4. \u00a0 \u5148\u53f3\u65cb\u540e\u5de6\u65cb","text":"

    \u5982\u56fe 7-31 \u6240\u793a\uff0c\u5bf9\u4e8e\u4e0a\u8ff0\u5931\u8861\u4e8c\u53c9\u6811\u7684\u955c\u50cf\u60c5\u51b5\uff0c\u9700\u8981\u5148\u5bf9 child \u6267\u884c\u201c\u53f3\u65cb\u201d\uff0c\u518d\u5bf9 node \u6267\u884c\u201c\u5de6\u65cb\u201d\u3002

    \u56fe 7-31 \u00a0 \u5148\u53f3\u65cb\u540e\u5de6\u65cb

    "},{"location":"chapter_tree/avl_tree/#5","title":"5. \u00a0 \u65cb\u8f6c\u7684\u9009\u62e9","text":"

    \u56fe 7-32 \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\u5148\u5de6\u65cb\u540e\u53f3\u65cb\u3001\u5148\u53f3\u65cb\u540e\u5de6\u65cb\u3001\u5de6\u65cb\u7684\u64cd\u4f5c\u3002

    \u56fe 7-32 \u00a0 AVL \u6811\u7684\u56db\u79cd\u65cb\u8f6c\u60c5\u51b5

    \u5982\u4e0b\u8868\u6240\u793a\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\u56fe 7-32 \u4e2d\u7684\u54ea\u79cd\u60c5\u51b5\u3002

    \u8868 7-3 \u00a0 \u56db\u79cd\u65cb\u8f6c\u60c5\u51b5\u7684\u9009\u62e9\u6761\u4ef6

    \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\u5de6\u504f\u6811\uff09 \\(\\geq 0\\) \u53f3\u65cb \\(> 1\\) \uff08\u5de6\u504f\u6811\uff09 \\(<0\\) \u5148\u5de6\u65cb\u540e\u53f3\u65cb \\(< -1\\) \uff08\u53f3\u504f\u6811\uff09 \\(\\leq 0\\) \u5de6\u65cb \\(< -1\\) \uff08\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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    balance_factor = self.balance_factor(node)\n    # \u5de6\u504f\u6811\n    if balance_factor > 1:\n        if self.balance_factor(node.left) >= 0:\n            # \u53f3\u65cb\n            return self.right_rotate(node)\n        else:\n            # \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = self.left_rotate(node.left)\n            return self.right_rotate(node)\n    # \u53f3\u504f\u6811\n    elif balance_factor < -1:\n        if self.balance_factor(node.right) <= 0:\n            # \u5de6\u65cb\n            return self.left_rotate(node)\n        else:\n            # \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = self.right_rotate(node.right)\n            return self.left_rotate(node)\n    # \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node\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\n    int _balanceFactor = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (_balanceFactor > 1) {\n        if (balanceFactor(node->left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node->left = leftRotate(node->left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (_balanceFactor < -1) {\n        if (balanceFactor(node->right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node->right = rightRotate(node->right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\n
    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\n    int balanceFactor = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = leftRotate(node.left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = rightRotate(node.right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    int balanceFactorInt = BalanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactorInt > 1) {\n        if (BalanceFactor(node?.left) >= 0) {\n            // \u53f3\u65cb\n            return RightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node!.left = LeftRotate(node!.left);\n            return RightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactorInt < -1) {\n        if (BalanceFactor(node?.right) <= 0) {\n            // \u5de6\u65cb\n            return LeftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node!.right = RightRotate(node!.right);\n            return LeftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\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\n    bf := t.balanceFactor(node)\n    // \u5de6\u504f\u6811\n    if bf > 1 {\n        if t.balanceFactor(node.Left) >= 0 {\n            // \u53f3\u65cb\n            return t.rightRotate(node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.Left = t.leftRotate(node.Left)\n            return t.rightRotate(node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if bf < -1 {\n        if t.balanceFactor(node.Right) <= 0 {\n            // \u5de6\u65cb\n            return t.leftRotate(node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.Right = t.rightRotate(node.Right)\n            return t.leftRotate(node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    let balanceFactor = balanceFactor(node: node)\n    // \u5de6\u504f\u6811\n    if balanceFactor > 1 {\n        if self.balanceFactor(node: node?.left) >= 0 {\n            // \u53f3\u65cb\n            return rightRotate(node: node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node?.left = leftRotate(node: node?.left)\n            return rightRotate(node: node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if balanceFactor < -1 {\n        if self.balanceFactor(node: node?.right) <= 0 {\n            // \u5de6\u65cb\n            return leftRotate(node: node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node?.right = rightRotate(node: node?.right)\n            return leftRotate(node: node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    const balanceFactor = this.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (this.balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return this.#rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = this.#leftRotate(node.left);\n            return this.#rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (this.balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return this.#leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = this.#rightRotate(node.right);\n            return this.#leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n    const balanceFactor = this.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (this.balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return this.rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = this.leftRotate(node.left);\n            return this.rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (this.balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return this.leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = this.rightRotate(node.right);\n            return this.leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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\n  int factor = balanceFactor(node);\n  // \u5de6\u504f\u6811\n  if (factor > 1) {\n    if (balanceFactor(node!.left) >= 0) {\n      // \u53f3\u65cb\n      return rightRotate(node);\n    } else {\n      // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n      node.left = leftRotate(node.left);\n      return rightRotate(node);\n    }\n  }\n  // \u53f3\u504f\u6811\n  if (factor < -1) {\n    if (balanceFactor(node!.right) <= 0) {\n      // \u5de6\u65cb\n      return leftRotate(node);\n    } else {\n      // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n      node.right = rightRotate(node.right);\n      return leftRotate(node);\n    }\n  }\n  // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n  return node;\n}\n
    avl_tree.rs
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfn rotate(node: OptionTreeNodeRc) -> OptionTreeNodeRc {\n    // \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\n    let balance_factor = Self::balance_factor(node.clone());\n    // \u5de6\u504f\u6811\n    if balance_factor > 1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().left.clone()) >= 0 {\n            // \u53f3\u65cb\n            Self::right_rotate(Some(node))\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            let left = node.borrow().left.clone();\n            node.borrow_mut().left = Self::left_rotate(left);\n            Self::right_rotate(Some(node))\n        }\n    }\n    // \u53f3\u504f\u6811\n    else if balance_factor < -1 {\n        let node = node.unwrap();\n        if Self::balance_factor(node.borrow().right.clone()) <= 0 {\n            // \u5de6\u65cb\n            Self::left_rotate(Some(node))\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            let right = node.borrow().right.clone();\n            node.borrow_mut().right = Self::right_rotate(right);\n            Self::left_rotate(Some(node))\n        }\n    } else {\n        // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n        node\n    }\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\n    int bf = balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (bf > 1) {\n        if (balanceFactor(node->left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node->left = leftRotate(node->left);\n            return rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (bf < -1) {\n        if (balanceFactor(node->right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node->right = rightRotate(node->right);\n            return leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node;\n}\n
    avl_tree.kt
    /* \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\nfun rotate(node: TreeNode): TreeNode {\n    // \u83b7\u53d6\u8282\u70b9 node \u7684\u5e73\u8861\u56e0\u5b50\n    val balanceFactor = balanceFactor(node)\n    // \u5de6\u504f\u6811\n    if (balanceFactor > 1) {\n        if (balanceFactor(node.left) >= 0) {\n            // \u53f3\u65cb\n            return rightRotate(node)\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.left = leftRotate(node.left)\n            return rightRotate(node)\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balanceFactor < -1) {\n        if (balanceFactor(node.right) <= 0) {\n            // \u5de6\u65cb\n            return leftRotate(node)\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.right = rightRotate(node.right)\n            return leftRotate(node)\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{rotate}\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\n    var balance_factor = self.balanceFactor(node);\n    // \u5de6\u504f\u6811\n    if (balance_factor > 1) {\n        if (self.balanceFactor(node.?.left) >= 0) {\n            // \u53f3\u65cb\n            return self.rightRotate(node);\n        } else {\n            // \u5148\u5de6\u65cb\u540e\u53f3\u65cb\n            node.?.left = self.leftRotate(node.?.left);\n            return self.rightRotate(node);\n        }\n    }\n    // \u53f3\u504f\u6811\n    if (balance_factor < -1) {\n        if (self.balanceFactor(node.?.right) <= 0) {\n            // \u5de6\u65cb\n            return self.leftRotate(node);\n        } else {\n            // \u5148\u53f3\u65cb\u540e\u5de6\u65cb\n            node.?.right = self.rightRotate(node.?.right);\n            return self.leftRotate(node);\n        }\n    }\n    // \u5e73\u8861\u6811\uff0c\u65e0\u987b\u65cb\u8f6c\uff0c\u76f4\u63a5\u8fd4\u56de\n    return 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/#1_2","title":"1. \u00a0 \u63d2\u5165\u8282\u70b9","text":"

    AVL \u6811\u7684\u8282\u70b9\u63d2\u5165\u64cd\u4f5c\u4e0e\u4e8c\u53c9\u641c\u7d22\u6811\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\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def insert(self, val):\n    \"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\n    self._root = self.insert_helper(self._root, val)\n\ndef insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:\n    \"\"\"\u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\n    if node is None:\n        return TreeNode(val)\n    # 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9\n    if val < node.val:\n        node.left = self.insert_helper(node.left, val)\n    elif val > node.val:\n        node.right = self.insert_helper(node.right, val)\n    else:\n        # \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    # 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\n    return self.rotate(node)\n
    avl_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node->val)\n        node->left = insertHelper(node->left, val);\n    else if (val > node->val)\n        node->right = insertHelper(node->right, val);\n    else\n        return node;    // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n    root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode insertHelper(TreeNode node, int val) {\n    if (node == null)\n        return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val)\n        node.left = insertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = insertHelper(node.right, val);\n    else\n        return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid Insert(int val) {\n    root = InsertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? InsertHelper(TreeNode? node, int val) {\n    if (node == null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val)\n        node.left = InsertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = InsertHelper(node.right, val);\n    else\n        return node;     // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    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 */\n    node = Rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (t *aVLTree) insert(val int) {\n    t.root = t.insertHelper(t.root, val)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return NewTreeNode(val)\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if val < node.Val.(int) {\n        node.Left = t.insertHelper(node.Left, val)\n    } else if val > node.Val.(int) {\n        node.Right = t.insertHelper(node.Right, val)\n    } else {\n        // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = t.rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\nfunc insert(val: Int) {\n    root = insertHelper(node: root, val: val)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc insertHelper(node: TreeNode?, val: Int) -> TreeNode? {\n    var node = node\n    if node == nil {\n        return TreeNode(x: val)\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if val < node!.val {\n        node?.left = insertHelper(node: node?.left, val: val)\n    } else if val > node!.val {\n        node?.right = insertHelper(node: node?.right, val: val)\n    } else {\n        return node // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    updateHeight(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 */\n    node = rotate(node: node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val) {\n    this.root = this.#insertHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#insertHelper(node, val) {\n    if (node === null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val) node.left = this.#insertHelper(node.left, val);\n    else if (val > node.val)\n        node.right = this.#insertHelper(node.right, val);\n    else return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    this.#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 */\n    node = this.#rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(val: number): void {\n    this.root = this.insertHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\ninsertHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return new TreeNode(val);\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node.val) {\n        node.left = this.insertHelper(node.left, val);\n    } else if (val > node.val) {\n        node.right = this.insertHelper(node.right, val);\n    } else {\n        return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    this.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 */\n    node = this.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.dart
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int val) {\n  root = insertHelper(root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? insertHelper(TreeNode? node, int val) {\n  if (node == null) return TreeNode(val);\n  /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n  if (val < node.val)\n    node.left = insertHelper(node.left, val);\n  else if (val > node.val)\n    node.right = insertHelper(node.right, val);\n  else\n    return node; // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n  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 */\n  node = rotate(node);\n  // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return node;\n}\n
    avl_tree.rs
    /* \u63d2\u5165\u8282\u70b9 */\nfn insert(&mut self, val: i32) {\n    self.root = Self::insert_helper(self.root.clone(), val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfn insert_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {\n    match node {\n        Some(mut node) => {\n            /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n            match {\n                let node_val = node.borrow().val;\n                node_val\n            }\n            .cmp(&val)\n            {\n                Ordering::Greater => {\n                    let left = node.borrow().left.clone();\n                    node.borrow_mut().left = Self::insert_helper(left, val);\n                }\n                Ordering::Less => {\n                    let right = node.borrow().right.clone();\n                    node.borrow_mut().right = Self::insert_helper(right, val);\n                }\n                Ordering::Equal => {\n                    return Some(node); // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n                }\n            }\n            Self::update_height(Some(node.clone())); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n\n            /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n            node = Self::rotate(Some(node)).unwrap();\n            // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(node)\n        }\n        None => Some(TreeNode::new(val)),\n    }\n}\n
    avl_tree.c
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(AVLTree *tree, int val) {\n    tree->root = insertHelper(tree->root, val);\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *insertHelper(TreeNode *node, int val) {\n    if (node == NULL) {\n        return newTreeNode(val);\n    }\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (val < node->val) {\n        node->left = insertHelper(node->left, val);\n    } else if (val > node->val) {\n        node->right = insertHelper(node->right, val);\n    } else {\n        // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n        return node;\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.kt
    /* \u63d2\u5165\u8282\u70b9 */\nfun insert(value: Int) {\n    root = insertHelper(root, value)\n}\n\n/* \u9012\u5f52\u63d2\u5165\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfun insertHelper(n: TreeNode?, value: Int): TreeNode {\n    if (n == null)\n        return TreeNode(value)\n    var node = n\n    /* 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9 */\n    if (value < node.value) node.left = insertHelper(node.left, value)\n    else if (value > node.value) node.right = insertHelper(node.right, value)\n    else return node // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n\n    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 */\n    node = rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{insert}\n\n[class]{AVLTree}-[func]{insert_helper}\n
    avl_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, val: T) !void {\n    self.root = (try self.insertHelper(self.root, val)).?;\n}\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) {\n    var node = node_;\n    if (node == null) {\n        var tmp_node = try self.mem_allocator.create(inc.TreeNode(T));\n        tmp_node.init(val);\n        return tmp_node;\n    }\n    // 1. \u67e5\u627e\u63d2\u5165\u4f4d\u7f6e\u5e76\u63d2\u5165\u8282\u70b9\n    if (val < node.?.val) {\n        node.?.left = try self.insertHelper(node.?.left, val);\n    } else if (val > node.?.val) {\n        node.?.right = try self.insertHelper(node.?.right, val);\n    } else {\n        return node;            // \u91cd\u590d\u8282\u70b9\u4e0d\u63d2\u5165\uff0c\u76f4\u63a5\u8fd4\u56de\n    }\n    self.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\n    node = self.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#2_2","title":"2. \u00a0 \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\u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u6240\u6709\u5931\u8861\u8282\u70b9\u6062\u590d\u5e73\u8861\u3002\u4ee3\u7801\u5982\u4e0b\u6240\u793a\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig avl_tree.py
    def remove(self, val: int):\n    \"\"\"\u5220\u9664\u8282\u70b9\"\"\"\n    self._root = self.remove_helper(self._root, val)\n\ndef remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:\n    \"\"\"\u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09\"\"\"\n    if node is None:\n        return None\n    # 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664\n    if val < node.val:\n        node.left = self.remove_helper(node.left, val)\n    elif val > node.val:\n        node.right = self.remove_helper(node.right, val)\n    else:\n        if node.left is None or node.right is None:\n            child = node.left or node.right\n            # \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if child is None:\n                return None\n            # \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else:\n                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\n            temp = node.right\n            while temp.left is not None:\n                temp = temp.left\n            node.right = self.remove_helper(node.right, temp.val)\n            node.val = temp.val\n    # \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    self.update_height(node)\n    # 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861\n    return self.rotate(node)\n
    avl_tree.cpp
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    if (node == nullptr)\n        return nullptr;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node->val)\n        node->left = removeHelper(node->left, val);\n    else if (val > node->val)\n        node->right = removeHelper(node->right, val);\n    else {\n        if (node->left == nullptr || node->right == nullptr) {\n            TreeNode *child = node->left != nullptr ? node->left : node->right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == nullptr) {\n                delete node;\n                return nullptr;\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else {\n                delete node;\n                node = 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\n            TreeNode *temp = node->right;\n            while (temp->left != nullptr) {\n                temp = temp->left;\n            }\n            int tempVal = temp->val;\n            node->right = removeHelper(node->right, temp->val);\n            node->val = tempVal;\n        }\n    }\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n    root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode removeHelper(TreeNode node, int val) {\n    if (node == null)\n        return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val)\n        node.left = removeHelper(node.left, val);\n    else if (val > node.val)\n        node.right = removeHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode child = node.left != null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == null)\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else\n                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\n            TreeNode temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    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 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.cs
    /* \u5220\u9664\u8282\u70b9 */\nvoid Remove(int val) {\n    root = RemoveHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? RemoveHelper(TreeNode? node, int val) {\n    if (node == null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val)\n        node.left = RemoveHelper(node.left, val);\n    else if (val > node.val)\n        node.right = RemoveHelper(node.right, val);\n    else {\n        if (node.left == null || node.right == null) {\n            TreeNode? child = node.left ?? node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == null)\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else\n                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\n            TreeNode? temp = node.right;\n            while (temp.left != null) {\n                temp = temp.left;\n            }\n            node.right = RemoveHelper(node.right, temp.val!.Value);\n            node.val = temp.val;\n        }\n    }\n    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 */\n    node = Rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (t *aVLTree) remove(val int) {\n    t.root = t.removeHelper(t.root, val)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nfunc (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {\n    if node == nil {\n        return nil\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if val < node.Val.(int) {\n        node.Left = t.removeHelper(node.Left, val)\n    } else if val > node.Val.(int) {\n        node.Right = t.removeHelper(node.Right, val)\n    } else {\n        if node.Left == nil || node.Right == nil {\n            child := node.Left\n            if node.Right != nil {\n                child = node.Right\n            }\n            if child == nil {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n                return nil\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            temp := node.Right\n            for temp.Left != nil {\n                temp = temp.Left\n            }\n            node.Right = t.removeHelper(node.Right, temp.Val.(int))\n            node.Val = temp.Val\n        }\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    t.updateHeight(node)\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = t.rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\nfunc remove(val: Int) {\n    root = removeHelper(node: root, val: val)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfunc removeHelper(node: TreeNode?, val: Int) -> TreeNode? {\n    var node = node\n    if node == nil {\n        return nil\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if val < node!.val {\n        node?.left = removeHelper(node: node?.left, val: val)\n    } else if val > node!.val {\n        node?.right = removeHelper(node: node?.right, val: val)\n    } else {\n        if node?.left == nil || node?.right == nil {\n            let child = node?.left ?? node?.right\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if child == nil {\n                return nil\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else {\n                node = 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\n            var temp = node?.right\n            while temp?.left != nil {\n                temp = temp?.left\n            }\n            node?.right = removeHelper(node: node?.right, val: temp!.val)\n            node?.val = temp!.val\n        }\n    }\n    updateHeight(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 */\n    node = rotate(node: node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nremove(val) {\n    this.root = this.#removeHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\n#removeHelper(node, val) {\n    if (node === null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val) node.left = this.#removeHelper(node.left, val);\n    else if (val > node.val)\n        node.right = this.#removeHelper(node.right, val);\n    else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child === null) return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            else 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\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.#removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.#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 */\n    node = this.#rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nremove(val: number): void {\n    this.root = this.removeHelper(this.root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nremoveHelper(node: TreeNode, val: number): TreeNode {\n    if (node === null) return null;\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node.val) {\n        node.left = this.removeHelper(node.left, val);\n    } else if (val > node.val) {\n        node.right = this.removeHelper(node.right, val);\n    } else {\n        if (node.left === null || node.right === null) {\n            const child = node.left !== null ? node.left : node.right;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child === null) {\n                return null;\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            let temp = node.right;\n            while (temp.left !== null) {\n                temp = temp.left;\n            }\n            node.right = this.removeHelper(node.right, temp.val);\n            node.val = temp.val;\n        }\n    }\n    this.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 */\n    node = this.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.dart
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int val) {\n  root = removeHelper(root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nTreeNode? removeHelper(TreeNode? node, int val) {\n  if (node == null) return null;\n  /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n  if (val < node.val)\n    node.left = removeHelper(node.left, val);\n  else if (val > node.val)\n    node.right = removeHelper(node.right, val);\n  else {\n    if (node.left == null || node.right == null) {\n      TreeNode? child = node.left ?? node.right;\n      // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n      if (child == null)\n        return null;\n      // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n      else\n        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\n      TreeNode? temp = node.right;\n      while (temp!.left != null) {\n        temp = temp.left;\n      }\n      node.right = removeHelper(node.right, temp.val);\n      node.val = temp.val;\n    }\n  }\n  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 */\n  node = rotate(node);\n  // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n  return node;\n}\n
    avl_tree.rs
    /* \u5220\u9664\u8282\u70b9 */\nfn remove(&self, val: i32) {\n    Self::remove_helper(self.root.clone(), val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfn remove_helper(node: OptionTreeNodeRc, val: i32) -> OptionTreeNodeRc {\n    match node {\n        Some(mut node) => {\n            /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n            if val < node.borrow().val {\n                let left = node.borrow().left.clone();\n                node.borrow_mut().left = Self::remove_helper(left, val);\n            } else if val > node.borrow().val {\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, val);\n            } else if node.borrow().left.is_none() || node.borrow().right.is_none() {\n                let child = if node.borrow().left.is_some() {\n                    node.borrow().left.clone()\n                } else {\n                    node.borrow().right.clone()\n                };\n                match child {\n                    // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n                    None => {\n                        return None;\n                    }\n                    // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                    Some(child) => node = 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\n                let mut temp = node.borrow().right.clone().unwrap();\n                loop {\n                    let temp_left = temp.borrow().left.clone();\n                    if temp_left.is_none() {\n                        break;\n                    }\n                    temp = temp_left.unwrap();\n                }\n                let right = node.borrow().right.clone();\n                node.borrow_mut().right = Self::remove_helper(right, temp.borrow().val);\n                node.borrow_mut().val = temp.borrow().val;\n            }\n            Self::update_height(Some(node.clone())); // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n\n            /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n            node = Self::rotate(Some(node)).unwrap();\n            // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n            Some(node)\n        }\n        None => None,\n    }\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 removeItem(AVLTree *tree, int val) {\n    TreeNode *root = removeHelper(tree->root, val);\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u51fd\u6570\uff09 */\nTreeNode *removeHelper(TreeNode *node, int val) {\n    TreeNode *child, *grandChild;\n    if (node == NULL) {\n        return NULL;\n    }\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (val < node->val) {\n        node->left = removeHelper(node->left, val);\n    } else if (val > node->val) {\n        node->right = removeHelper(node->right, val);\n    } else {\n        if (node->left == NULL || node->right == NULL) {\n            child = node->left;\n            if (node->right != NULL) {\n                child = node->right;\n            }\n            // \u5b50\u8282\u70b9\u6570\u91cf = 0 \uff0c\u76f4\u63a5\u5220\u9664 node \u5e76\u8fd4\u56de\n            if (child == NULL) {\n                return NULL;\n            } else {\n                // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n                node = 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\n            TreeNode *temp = node->right;\n            while (temp->left != NULL) {\n                temp = temp->left;\n            }\n            int tempVal = temp->val;\n            node->right = removeHelper(node->right, temp->val);\n            node->val = tempVal;\n        }\n    }\n    // \u66f4\u65b0\u8282\u70b9\u9ad8\u5ea6\n    updateHeight(node);\n    /* 2. \u6267\u884c\u65cb\u8f6c\u64cd\u4f5c\uff0c\u4f7f\u8be5\u5b50\u6811\u91cd\u65b0\u6062\u590d\u5e73\u8861 */\n    node = rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    avl_tree.kt
    /* \u5220\u9664\u8282\u70b9 */\nfun remove(value: Int) {\n    root = removeHelper(root, value)\n}\n\n/* \u9012\u5f52\u5220\u9664\u8282\u70b9\uff08\u8f85\u52a9\u65b9\u6cd5\uff09 */\nfun removeHelper(n: TreeNode?, value: Int): TreeNode? {\n    var node = n ?: return null\n    /* 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664 */\n    if (value < node.value) node.left = removeHelper(node.left, value)\n    else if (value > node.value) node.right = removeHelper(node.right, value)\n    else {\n        if (node.left == null || node.right == null) {\n            val 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\n            if (child == null) return null\n            else 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\n            var temp = node.right\n            while (temp!!.left != null) {\n                temp = temp.left\n            }\n            node.right = removeHelper(node.right, temp.value)\n            node.value = temp.value\n        }\n    }\n    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 */\n    node = rotate(node)\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node\n}\n
    avl_tree.rb
    [class]{AVLTree}-[func]{remove}\n\n[class]{AVLTree}-[func]{remove_helper}\n
    avl_tree.zig
    // \u5220\u9664\u8282\u70b9\nfn remove(self: *Self, val: T) void {\n   self.root = self.removeHelper(self.root, val).?;\n}\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) {\n    var node = node_;\n    if (node == null) return null;\n    // 1. \u67e5\u627e\u8282\u70b9\u5e76\u5220\u9664\n    if (val < node.?.val) {\n        node.?.left = self.removeHelper(node.?.left, val);\n    } else if (val > node.?.val) {\n        node.?.right = self.removeHelper(node.?.right, val);\n    } else {\n        if (node.?.left == null or node.?.right == null) {\n            var 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\n            if (child == null) {\n                return null;\n            // \u5b50\u8282\u70b9\u6570\u91cf = 1 \uff0c\u76f4\u63a5\u5220\u9664 node\n            } else {\n                node = 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\n            var temp = node.?.right;\n            while (temp.?.left != null) {\n                temp = temp.?.left;\n            }\n            node.?.right = self.removeHelper(node.?.right, temp.?.val);\n            node.?.val = temp.?.val;\n        }\n    }\n    self.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\n    node = self.rotate(node);\n    // \u8fd4\u56de\u5b50\u6811\u7684\u6839\u8282\u70b9\n    return node;\n}\n
    "},{"location":"chapter_tree/avl_tree/#3_1","title":"3. \u00a0 \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\u3002
    • \u7528\u4e8e\u6784\u5efa\u6570\u636e\u5e93\u4e2d\u7684\u7d22\u5f15\u7cfb\u7edf\u3002
    • \u7ea2\u9ed1\u6811\u4e5f\u662f\u4e00\u79cd\u5e38\u89c1\u7684\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\u3002\u76f8\u8f83\u4e8e AVL \u6811\uff0c\u7ea2\u9ed1\u6811\u7684\u5e73\u8861\u6761\u4ef6\u66f4\u5bbd\u677e\uff0c\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u6240\u9700\u7684\u65cb\u8f6c\u64cd\u4f5c\u66f4\u5c11\uff0c\u8282\u70b9\u589e\u5220\u64cd\u4f5c\u7684\u5e73\u5747\u6548\u7387\u66f4\u9ad8\u3002
    "},{"location":"chapter_tree/binary_search_tree/","title":"7.4 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811","text":"

    \u5982\u56fe 7-16 \u6240\u793a\uff0c\u300c\u4e8c\u53c9\u641c\u7d22\u6811 binary search tree\u300d\u6ee1\u8db3\u4ee5\u4e0b\u6761\u4ef6\u3002

    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\u3002
    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. \u3002

    \u56fe 7-16 \u00a0 \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":"

    \u6211\u4eec\u5c06\u4e8c\u53c9\u641c\u7d22\u6811\u5c01\u88c5\u4e3a\u4e00\u4e2a\u7c7b BinarySearchTree \uff0c\u5e76\u58f0\u660e\u4e00\u4e2a\u6210\u5458\u53d8\u91cf root \uff0c\u6307\u5411\u6811\u7684\u6839\u8282\u70b9\u3002

    "},{"location":"chapter_tree/binary_search_tree/#1","title":"1. \u00a0 \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\u5982\u56fe 7-17 \u6240\u793a\uff0c\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\u3002

    • \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 \u3002
    • \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 \u3002
    • \u82e5 cur.val = num \uff0c\u8bf4\u660e\u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\u5e76\u8fd4\u56de\u8be5\u8282\u70b9\u3002
    <1><2><3><4>

    \u56fe 7-17 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u67e5\u627e\u8282\u70b9\u793a\u4f8b

    \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\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def search(self, num: int) -> TreeNode | None:\n    \"\"\"\u67e5\u627e\u8282\u70b9\"\"\"\n    cur = self._root\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur is not None:\n        # \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        elif cur.val > num:\n            cur = cur.left\n        # \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else:\n            break\n    return cur\n
    binary_search_tree.cpp
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(int num) {\n    TreeNode *cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur->val > num)\n            cur = cur->left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.java
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode search(int num) {\n    TreeNode cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num)\n            cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.cs
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode? Search(int num) {\n    TreeNode? cur = root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur =\n            cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num)\n            cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else\n            break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.go
    /* \u67e5\u627e\u8282\u70b9 */\nfunc (bst *binarySearchTree) search(num int) *TreeNode {\n    node := bst.root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for node != nil {\n        if node.Val.(int) < num {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            node = node.Right\n        } else if node.Val.(int) > num {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            node = node.Left\n        } else {\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            break\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return node\n}\n
    binary_search_tree.swift
    /* \u67e5\u627e\u8282\u70b9 */\nfunc search(num: Int) -> TreeNode? {\n    var cur = root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if cur!.val > num {\n            cur = cur?.left\n        }\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else {\n            break\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur\n}\n
    binary_search_tree.js
    /* \u67e5\u627e\u8282\u70b9 */\nsearch(num) {\n    let cur = this.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num) cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.ts
    /* \u67e5\u627e\u8282\u70b9 */\nsearch(num: number): TreeNode | null {\n    let cur = this.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.val > num) cur = cur.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break;\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.dart
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode? search(int _num) {\n  TreeNode? cur = _root;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else if (cur.val > _num)\n      cur = cur.left;\n    // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n    else\n      break;\n  }\n  // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n  return cur;\n}\n
    binary_search_tree.rs
    /* \u67e5\u627e\u8282\u70b9 */\npub fn search(&self, num: i32) -> OptionTreeNodeRc {\n    let mut cur = self.root.clone();\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => cur = node.borrow().right.clone(),\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => cur = node.borrow().left.clone(),\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            Ordering::Equal => break,\n        }\n    }\n\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    cur\n}\n
    binary_search_tree.c
    /* \u67e5\u627e\u8282\u70b9 */\nTreeNode *search(BinarySearchTree *bst, int num) {\n    TreeNode *cur = bst->root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        if (cur->val < num) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else if (cur->val > num) {\n            // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        } else {\n            // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            break;\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    binary_search_tree.kt
    /* \u67e5\u627e\u8282\u70b9 */\nfun search(num: Int): TreeNode? {\n    var cur = root\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else if (cur.value > num) cur.left\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        else break\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{search}\n
    binary_search_tree.zig
    // \u67e5\u627e\u8282\u70b9\nfn search(self: *Self, num: T) ?*inc.TreeNode(T) {\n    var cur = self.root;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u76ee\u6807\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else if (cur.?.val > num) {\n            cur = cur.?.left;\n        // \u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        } else {\n            break;\n        }\n    }\n    // \u8fd4\u56de\u76ee\u6807\u8282\u70b9\n    return cur;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/binary_search_tree/#2","title":"2. \u00a0 \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\u6d41\u7a0b\u5982\u56fe 7-18 \u6240\u793a\u3002

    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 None \uff09\u65f6\u8df3\u51fa\u5faa\u73af\u3002
    2. \u5728\u8be5\u4f4d\u7f6e\u63d2\u5165\u8282\u70b9\uff1a\u521d\u59cb\u5316\u8282\u70b9 num \uff0c\u5c06\u8be5\u8282\u70b9\u7f6e\u4e8e None \u7684\u4f4d\u7f6e\u3002

    \u56fe 7-18 \u00a0 \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u63d2\u5165\u8282\u70b9

    \u5728\u4ee3\u7801\u5b9e\u73b0\u4e2d\uff0c\u9700\u8981\u6ce8\u610f\u4ee5\u4e0b\u4e24\u70b9\u3002

    • \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
    • \u4e3a\u4e86\u5b9e\u73b0\u63d2\u5165\u8282\u70b9\uff0c\u6211\u4eec\u9700\u8981\u501f\u52a9\u8282\u70b9 pre \u4fdd\u5b58\u4e0a\u4e00\u8f6e\u5faa\u73af\u7684\u8282\u70b9\u3002\u8fd9\u6837\u5728\u904d\u5386\u81f3 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
    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def insert(self, num: int):\n    \"\"\"\u63d2\u5165\u8282\u70b9\"\"\"\n    # \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if self._root is None:\n        self._root = TreeNode(num)\n        return\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    cur, pre = self._root, None\n    while cur is not None:\n        # \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if cur.val == num:\n            return\n        pre = cur\n        # \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else:\n            cur = cur.left\n    # \u63d2\u5165\u8282\u70b9\n    node = TreeNode(num)\n    if pre.val < num:\n        pre.right = node\n    else:\n        pre.left = node\n
    binary_search_tree.cpp
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == nullptr) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode *cur = root, *pre = nullptr;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur->val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur->left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode *node = new TreeNode(num);\n    if (pre->val < num)\n        pre->right = node;\n    else\n        pre->left = node;\n}\n
    binary_search_tree.java
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode node = new TreeNode(num);\n    if (pre.val < num)\n        pre.right = node;\n    else\n        pre.left = node;\n}\n
    binary_search_tree.cs
    /* \u63d2\u5165\u8282\u70b9 */\nvoid Insert(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = new TreeNode(num);\n        return;\n    }\n    TreeNode? cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val == num)\n            return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode node = new(num);\n    if (pre != null) {\n        if (pre.val < num)\n            pre.right = node;\n        else\n            pre.left = node;\n    }\n}\n
    binary_search_tree.go
    /* \u63d2\u5165\u8282\u70b9 */\nfunc (bst *binarySearchTree) insert(num int) {\n    cur := bst.root\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if cur == nil {\n        bst.root = NewTreeNode(num)\n        return\n    }\n    // \u5f85\u63d2\u5165\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\n    var pre *TreeNode = nil\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for cur != nil {\n        if cur.Val == num {\n            return\n        }\n        pre = cur\n        if cur.Val.(int) < num {\n            cur = cur.Right\n        } else {\n            cur = cur.Left\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    node := NewTreeNode(num)\n    if pre.Val.(int) < num {\n        pre.Right = node\n    } else {\n        pre.Left = node\n    }\n}\n
    binary_search_tree.swift
    /* \u63d2\u5165\u8282\u70b9 */\nfunc insert(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if root == nil {\n        root = TreeNode(x: num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if cur!.val == num {\n            return\n        }\n        pre = cur\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else {\n            cur = cur?.left\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    let node = TreeNode(x: num)\n    if pre!.val < num {\n        pre?.right = node\n    } else {\n        pre?.left = node\n    }\n}\n
    binary_search_tree.js
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur = this.root,\n        pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val === num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    const node = new TreeNode(num);\n    if (pre.val < num) pre.right = node;\n    else pre.left = node;\n}\n
    binary_search_tree.ts
    /* \u63d2\u5165\u8282\u70b9 */\ninsert(num: number): void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (this.root === null) {\n        this.root = new TreeNode(num);\n        return;\n    }\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.val === num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u63d2\u5165\u8282\u70b9\n    const node = new TreeNode(num);\n    if (pre!.val < num) pre!.right = node;\n    else pre!.left = node;\n}\n
    binary_search_tree.dart
    /* \u63d2\u5165\u8282\u70b9 */\nvoid insert(int _num) {\n  // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n  if (_root == null) {\n    _root = TreeNode(_num);\n    return;\n  }\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n    if (cur.val == _num) return;\n    pre = cur;\n    // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else\n      cur = cur.left;\n  }\n  // \u63d2\u5165\u8282\u70b9\n  TreeNode? node = TreeNode(_num);\n  if (pre!.val < _num)\n    pre.right = node;\n  else\n    pre.left = node;\n}\n
    binary_search_tree.rs
    /* \u63d2\u5165\u8282\u70b9 */\npub fn insert(&mut self, num: i32) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if self.root.is_none() {\n        self.root = Some(TreeNode::new(num));\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n            Ordering::Equal => return,\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    let pre = pre.unwrap();\n    let node = Some(TreeNode::new(num));\n    if num > pre.borrow().val {\n        pre.borrow_mut().right = node;\n    } else {\n        pre.borrow_mut().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\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (bst->root == NULL) {\n        bst->root = newTreeNode(num);\n        return;\n    }\n    TreeNode *cur = bst->root, *pre = NULL;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur->val == num) {\n            return;\n        }\n        pre = cur;\n        if (cur->val < num) {\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else {\n            // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    TreeNode *node = newTreeNode(num);\n    if (pre->val < num) {\n        pre->right = node;\n    } else {\n        pre->left = node;\n    }\n}\n
    binary_search_tree.kt
    /* \u63d2\u5165\u8282\u70b9 */\nfun insert(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (root == null) {\n        root = TreeNode(num)\n        return\n    }\n    var cur = root\n    var pre: TreeNode? = null\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.value == num) return\n        pre = cur\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur.left\n    }\n    // \u63d2\u5165\u8282\u70b9\n    val node = TreeNode(num)\n    if (pre?.value!! < num) pre.right = node\n    else pre.left = node\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{insert}\n
    binary_search_tree.zig
    // \u63d2\u5165\u8282\u70b9\nfn insert(self: *Self, num: T) !void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u5219\u521d\u59cb\u5316\u6839\u8282\u70b9\n    if (self.root == null) {\n        self.root = try self.mem_allocator.create(inc.TreeNode(T));\n        return;\n    }\n    var cur = self.root;\n    var pre: ?*inc.TreeNode(T) = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u91cd\u590d\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n        if (cur.?.val == num) return;\n        pre = cur;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u63d2\u5165\u4f4d\u7f6e\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else {\n            cur = cur.?.left;\n        }\n    }\n    // \u63d2\u5165\u8282\u70b9\n    var node = try self.mem_allocator.create(inc.TreeNode(T));\n    node.init(num);\n    if (pre.?.val < num) {\n        pre.?.right = node;\n    } else {\n        pre.?.left = node;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    \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":"3. \u00a0 \u5220\u9664\u8282\u70b9","text":"

    \u5148\u5728\u4e8c\u53c9\u6811\u4e2d\u67e5\u627e\u5230\u76ee\u6807\u8282\u70b9\uff0c\u518d\u5c06\u5176\u5220\u9664\u3002\u4e0e\u63d2\u5165\u8282\u70b9\u7c7b\u4f3c\uff0c\u6211\u4eec\u9700\u8981\u4fdd\u8bc1\u5728\u5220\u9664\u64cd\u4f5c\u5b8c\u6210\u540e\uff0c\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u201c\u5de6\u5b50\u6811 < \u6839\u8282\u70b9 < \u53f3\u5b50\u6811\u201d\u7684\u6027\u8d28\u4ecd\u7136\u6ee1\u8db3\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u6839\u636e\u76ee\u6807\u8282\u70b9\u7684\u5b50\u8282\u70b9\u6570\u91cf\uff0c\u5206 0\u30011 \u548c 2 \u4e09\u79cd\u60c5\u51b5\uff0c\u6267\u884c\u5bf9\u5e94\u7684\u5220\u9664\u8282\u70b9\u64cd\u4f5c\u3002

    \u5982\u56fe 7-19 \u6240\u793a\uff0c\u5f53\u5f85\u5220\u9664\u8282\u70b9\u7684\u5ea6\u4e3a \\(0\\) \u65f6\uff0c\u8868\u793a\u8be5\u8282\u70b9\u662f\u53f6\u8282\u70b9\uff0c\u53ef\u4ee5\u76f4\u63a5\u5220\u9664\u3002

    \u56fe 7-19 \u00a0 \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u5220\u9664\u8282\u70b9\uff08\u5ea6\u4e3a 0 \uff09

    \u5982\u56fe 7-20 \u6240\u793a\uff0c\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

    \u56fe 7-20 \u00a0 \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\u5b50\u6811 \\(<\\) \u6839\u8282\u70b9 \\(<\\) \u53f3\u5b50\u6811\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\u4e2d\u5e8f\u904d\u5386\u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\uff09\uff0c\u5219\u5220\u9664\u64cd\u4f5c\u6d41\u7a0b\u5982\u56fe 7-21 \u6240\u793a\u3002

    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 \u3002
    2. \u7528 tmp \u7684\u503c\u8986\u76d6\u5f85\u5220\u9664\u8282\u70b9\u7684\u503c\uff0c\u5e76\u5728\u6811\u4e2d\u9012\u5f52\u5220\u9664\u8282\u70b9 tmp \u3002
    <1><2><3><4>

    \u56fe 7-21 \u00a0 \u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4e2d\u5220\u9664\u8282\u70b9\uff08\u5ea6\u4e3a 2 \uff09

    \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\u793a\u4f8b\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_search_tree.py
    def remove(self, num: int):\n    \"\"\"\u5220\u9664\u8282\u70b9\"\"\"\n    # \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if self._root is None:\n        return\n    # \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    cur, pre = self._root, None\n    while cur is not None:\n        # \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if cur.val == num:\n            break\n        pre = cur\n        # \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur.val < num:\n            cur = cur.right\n        # \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else:\n            cur = cur.left\n    # \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur is None:\n        return\n\n    # \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if 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\n        child = cur.left or cur.right\n        # \u5220\u9664\u8282\u70b9 cur\n        if cur != self._root:\n            if pre.left == cur:\n                pre.left = child\n            else:\n                pre.right = child\n        else:\n            # \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            self._root = child\n    # \u5b50\u8282\u70b9\u6570\u91cf = 2\n    else:\n        # \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n        tmp: TreeNode = cur.right\n        while tmp.left is not None:\n            tmp = tmp.left\n        # \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        self.remove(tmp.val)\n        # \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val\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\n    if (root == nullptr)\n        return;\n    TreeNode *cur = root, *pre = nullptr;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != nullptr) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur->val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur->val < num)\n            cur = cur->right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur->left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == nullptr)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur->left == nullptr || cur->right == nullptr) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\n        TreeNode *child = cur->left != nullptr ? cur->left : cur->right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre->left == cur)\n                pre->left = child;\n            else\n                pre->right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\n        // \u91ca\u653e\u5185\u5b58\n        delete cur;\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\n        TreeNode *tmp = cur->right;\n        while (tmp->left != nullptr) {\n            tmp = tmp->left;\n        }\n        int tmpVal = tmp->val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp->val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur->val = tmpVal;\n    }\n}\n
    binary_search_tree.java
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (root == null)\n        return;\n    TreeNode cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        TreeNode child = cur.left != null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\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\n        TreeNode tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\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\n    if (root == null)\n        return;\n    TreeNode? cur = root, pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val == num)\n            break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num)\n            cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else\n            cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null)\n        return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        TreeNode? child = cur.left ?? cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre!.left == cur)\n                pre.left = child;\n            else\n                pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child;\n        }\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\n        TreeNode? tmp = cur.right;\n        while (tmp.left != null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        Remove(tmp.val!.Value);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\n    }\n}\n
    binary_search_tree.go
    /* \u5220\u9664\u8282\u70b9 */\nfunc (bst *binarySearchTree) remove(num int) {\n    cur := bst.root\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5f85\u5220\u9664\u8282\u70b9\u4e4b\u524d\u7684\u8282\u70b9\u4f4d\u7f6e\n    var pre *TreeNode = nil\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    for cur != nil {\n        if cur.Val == num {\n            break\n        }\n        pre = cur\n        if cur.Val.(int) < num {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728\u53f3\u5b50\u6811\u4e2d\n            cur = cur.Right\n        } else {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728\u5de6\u5b50\u6811\u4e2d\n            cur = cur.Left\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5b50\u8282\u70b9\u6570\u4e3a 0 \u6216 1\n    if cur.Left == nil || cur.Right == nil {\n        var child *TreeNode = nil\n        // \u53d6\u51fa\u5f85\u5220\u9664\u8282\u70b9\u7684\u5b50\u8282\u70b9\n        if cur.Left != nil {\n            child = cur.Left\n        } else {\n            child = cur.Right\n        }\n        // \u5220\u9664\u8282\u70b9 cur\n        if cur != bst.root {\n            if pre.Left == cur {\n                pre.Left = child\n            } else {\n                pre.Right = child\n            }\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            bst.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\n        tmp := cur.Right\n        for tmp.Left != nil {\n            tmp = tmp.Left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        bst.remove(tmp.Val.(int))\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.Val = tmp.Val\n    }\n}\n
    binary_search_tree.swift
    /* \u5220\u9664\u8282\u70b9 */\nfunc remove(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if root == nil {\n        return\n    }\n    var cur = root\n    var pre: TreeNode?\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while cur != nil {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if cur!.val == num {\n            break\n        }\n        pre = cur\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if cur!.val < num {\n            cur = cur?.right\n        }\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else {\n            cur = cur?.left\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur == nil {\n        return\n    }\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if cur?.left == nil || cur?.right == nil {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        let child = cur?.left ?? cur?.right\n        // \u5220\u9664\u8282\u70b9 cur\n        if cur !== root {\n            if pre?.left === cur {\n                pre?.left = child\n            } else {\n                pre?.right = child\n            }\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = child\n        }\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\n        var tmp = cur?.right\n        while tmp?.left != nil {\n            tmp = tmp?.left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(num: tmp!.val)\n        // \u7528 tmp \u8986\u76d6 cur\n        cur?.val = tmp!.val\n    }\n}\n
    binary_search_tree.js
    /* \u5220\u9664\u8282\u70b9 */\nremove(num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (this.root === null) return;\n    let cur = this.root,\n        pre = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val === num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur === null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        const child = cur.left !== null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur !== this.root) {\n            if (pre.left === cur) pre.left = child;\n            else pre.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            this.root = child;\n        }\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\n        let tmp = cur.right;\n        while (tmp.left !== null) {\n            tmp = tmp.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        this.remove(tmp.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp.val;\n    }\n}\n
    binary_search_tree.ts
    /* \u5220\u9664\u8282\u70b9 */\nremove(num: number): void {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (this.root === null) return;\n    let cur: TreeNode | null = this.root,\n        pre: TreeNode | null = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur !== null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.val === num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.val < num) cur = cur.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur = cur.left;\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur === null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left === null || cur.right === null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        const child: TreeNode | null =\n            cur.left !== null ? cur.left : cur.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur !== this.root) {\n            if (pre!.left === cur) pre!.left = child;\n            else pre!.right = child;\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            this.root = child;\n        }\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\n        let tmp: TreeNode | null = cur.right;\n        while (tmp!.left !== null) {\n            tmp = tmp!.left;\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        this.remove(tmp!.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.val = tmp!.val;\n    }\n}\n
    binary_search_tree.dart
    /* \u5220\u9664\u8282\u70b9 */\nvoid remove(int _num) {\n  // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n  if (_root == null) return;\n  TreeNode? cur = _root;\n  TreeNode? pre = null;\n  // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n  while (cur != null) {\n    // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n    if (cur.val == _num) break;\n    pre = cur;\n    // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n    if (cur.val < _num)\n      cur = cur.right;\n    // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n    else\n      cur = cur.left;\n  }\n  // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u76f4\u63a5\u8fd4\u56de\n  if (cur == null) return;\n  // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n  if (cur.left == null || cur.right == null) {\n    // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n    TreeNode? child = cur.left ?? cur.right;\n    // \u5220\u9664\u8282\u70b9 cur\n    if (cur != _root) {\n      if (pre!.left == cur)\n        pre.left = child;\n      else\n        pre.right = child;\n    } else {\n      // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n      _root = 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\n    TreeNode? tmp = cur.right;\n    while (tmp!.left != null) {\n      tmp = tmp.left;\n    }\n    // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n    remove(tmp.val);\n    // \u7528 tmp \u8986\u76d6 cur\n    cur.val = tmp.val;\n  }\n}\n
    binary_search_tree.rs
    /* \u5220\u9664\u8282\u70b9 */\npub fn remove(&mut self, num: i32) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if self.root.is_none() {\n        return;\n    }\n    let mut cur = self.root.clone();\n    let mut pre = None;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while let Some(node) = cur.clone() {\n        match num.cmp(&node.borrow().val) {\n            // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n            Ordering::Equal => break,\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n            Ordering::Greater => {\n                pre = cur.clone();\n                cur = node.borrow().right.clone();\n            }\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n            Ordering::Less => {\n                pre = cur.clone();\n                cur = node.borrow().left.clone();\n            }\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if cur.is_none() {\n        return;\n    }\n    let cur = cur.unwrap();\n    let (left_child, right_child) = (cur.borrow().left.clone(), cur.borrow().right.clone());\n    match (left_child.clone(), right_child.clone()) {\n        // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n        (None, None) | (Some(_), None) | (None, Some(_)) => {\n            // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = nullptr / \u8be5\u5b50\u8282\u70b9\n            let child = left_child.or(right_child);\n            let pre = pre.unwrap();\n            // \u5220\u9664\u8282\u70b9 cur\n            if !Rc::ptr_eq(&cur, self.root.as_ref().unwrap()) {\n                let left = pre.borrow().left.clone();\n                if left.is_some() && Rc::ptr_eq(&left.as_ref().unwrap(), &cur) {\n                    pre.borrow_mut().left = child;\n                } else {\n                    pre.borrow_mut().right = child;\n                }\n            } else {\n                // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n                self.root = child;\n            }\n        }\n        // \u5b50\u8282\u70b9\u6570\u91cf = 2\n        (Some(_), Some(_)) => {\n            // \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n            let mut tmp = cur.borrow().right.clone();\n            while let Some(node) = tmp.clone() {\n                if node.borrow().left.is_some() {\n                    tmp = node.borrow().left.clone();\n                } else {\n                    break;\n                }\n            }\n            let tmpval = tmp.unwrap().borrow().val;\n            // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n            self.remove(tmpval);\n            // \u7528 tmp \u8986\u76d6 cur\n            cur.borrow_mut().val = tmpval;\n        }\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 removeItem(BinarySearchTree *bst, int num) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (bst->root == NULL)\n        return;\n    TreeNode *cur = bst->root, *pre = NULL;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != NULL) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur->val == num)\n            break;\n        pre = cur;\n        if (cur->val < num) {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u53f3\u5b50\u6811\u4e2d\n            cur = cur->right;\n        } else {\n            // \u5f85\u5220\u9664\u8282\u70b9\u5728 root \u7684\u5de6\u5b50\u6811\u4e2d\n            cur = cur->left;\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == NULL)\n        return;\n    // \u5224\u65ad\u5f85\u5220\u9664\u8282\u70b9\u662f\u5426\u5b58\u5728\u5b50\u8282\u70b9\n    if (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\n        TreeNode *child = cur->left != NULL ? cur->left : cur->right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (pre->left == cur) {\n            pre->left = child;\n        } else {\n            pre->right = child;\n        }\n        // \u91ca\u653e\u5185\u5b58\n        free(cur);\n    } else {\n        /* \u5b50\u8282\u70b9\u6570\u91cf = 2 */\n        // \u83b7\u53d6\u4e2d\u5e8f\u904d\u5386\u4e2d cur \u7684\u4e0b\u4e00\u4e2a\u8282\u70b9\n        TreeNode *tmp = cur->right;\n        while (tmp->left != NULL) {\n            tmp = tmp->left;\n        }\n        int tmpVal = tmp->val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        removeItem(bst, tmp->val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur->val = tmpVal;\n    }\n}\n
    binary_search_tree.kt
    /* \u5220\u9664\u8282\u70b9 */\nfun remove(num: Int) {\n    // \u82e5\u6811\u4e3a\u7a7a\uff0c\u76f4\u63a5\u63d0\u524d\u8fd4\u56de\n    if (root == null) return\n    var cur = root\n    var pre: TreeNode? = null\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.value == num) break\n        pre = cur\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        cur = if (cur.value < num) cur.right\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        else cur.left\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null) return\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.left == null || cur.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        val child = if (cur.left != null) cur.left else cur.right\n        // \u5220\u9664\u8282\u70b9 cur\n        if (cur != root) {\n            if (pre!!.left == cur) pre.left = child\n            else pre.right = child\n        } else {\n            // \u82e5\u5220\u9664\u8282\u70b9\u4e3a\u6839\u8282\u70b9\uff0c\u5219\u91cd\u65b0\u6307\u5b9a\u6839\u8282\u70b9\n            root = 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\n        var tmp = cur.right\n        while (tmp!!.left != null) {\n            tmp = tmp.left\n        }\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        remove(tmp.value)\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.value = tmp.value\n    }\n}\n
    binary_search_tree.rb
    [class]{BinarySearchTree}-[func]{remove}\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\n    if (self.root == null) return;\n    var cur = self.root;\n    var pre: ?*inc.TreeNode(T) = null;\n    // \u5faa\u73af\u67e5\u627e\uff0c\u8d8a\u8fc7\u53f6\u8282\u70b9\u540e\u8df3\u51fa\n    while (cur != null) {\n        // \u627e\u5230\u5f85\u5220\u9664\u8282\u70b9\uff0c\u8df3\u51fa\u5faa\u73af\n        if (cur.?.val == num) break;\n        pre = cur;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u53f3\u5b50\u6811\u4e2d\n        if (cur.?.val < num) {\n            cur = cur.?.right;\n        // \u5f85\u5220\u9664\u8282\u70b9\u5728 cur \u7684\u5de6\u5b50\u6811\u4e2d\n        } else {\n            cur = cur.?.left;\n        }\n    }\n    // \u82e5\u65e0\u5f85\u5220\u9664\u8282\u70b9\uff0c\u5219\u76f4\u63a5\u8fd4\u56de\n    if (cur == null) return;\n    // \u5b50\u8282\u70b9\u6570\u91cf = 0 or 1\n    if (cur.?.left == null or cur.?.right == null) {\n        // \u5f53\u5b50\u8282\u70b9\u6570\u91cf = 0 / 1 \u65f6\uff0c child = null / \u8be5\u5b50\u8282\u70b9\n        var child = if (cur.?.left != null) cur.?.left else cur.?.right;\n        // \u5220\u9664\u8282\u70b9 cur\n        if (pre.?.left == cur) {\n            pre.?.left = child;\n        } else {\n            pre.?.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\n        var tmp = cur.?.right;\n        while (tmp.?.left != null) {\n            tmp = tmp.?.left;\n        }\n        var tmp_val = tmp.?.val;\n        // \u9012\u5f52\u5220\u9664\u8282\u70b9 tmp\n        self.remove(tmp.?.val);\n        // \u7528 tmp \u8986\u76d6 cur\n        cur.?.val = tmp_val;\n    }\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/binary_search_tree/#4","title":"4. \u00a0 \u4e2d\u5e8f\u904d\u5386\u6709\u5e8f","text":"

    \u5982\u56fe 7-22 \u6240\u793a\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

    \u8fd9\u610f\u5473\u7740\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\u987b\u8fdb\u884c\u989d\u5916\u7684\u6392\u5e8f\u64cd\u4f5c\uff0c\u975e\u5e38\u9ad8\u6548\u3002

    \u56fe 7-22 \u00a0 \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\u8868 7-2 \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\u3002\u53ea\u6709\u5728\u9ad8\u9891\u6dfb\u52a0\u3001\u4f4e\u9891\u67e5\u627e\u5220\u9664\u6570\u636e\u7684\u573a\u666f\u4e0b\uff0c\u6570\u7ec4\u6bd4\u4e8c\u53c9\u641c\u7d22\u6811\u7684\u6548\u7387\u66f4\u9ad8\u3002

    \u8868 7-2 \u00a0 \u6570\u7ec4\u4e0e\u641c\u7d22\u6811\u7684\u6548\u7387\u5bf9\u6bd4

    \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\u56fe 7-23 \u6240\u793a\u7684\u94fe\u8868\uff0c\u8fd9\u65f6\u5404\u79cd\u64cd\u4f5c\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u4f1a\u9000\u5316\u4e3a \\(O(n)\\) \u3002

    \u56fe 7-23 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\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\u201c\u7956\u5148\u201d\u4e0e\u201c\u540e\u4ee3\u201d\u4e4b\u95f4\u7684\u6d3e\u751f\u5173\u7cfb\uff0c\u4f53\u73b0\u4e86\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\u503c\u3001\u5de6\u5b50\u8282\u70b9\u5f15\u7528\u548c\u53f3\u5b50\u8282\u70b9\u5f15\u7528\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 
    class TreeNode:\n    \"\"\"\u4e8c\u53c9\u6811\u8282\u70b9\u7c7b\"\"\"\n    def __init__(self, val: int):\n        self.val: int = val                # \u8282\u70b9\u503c\n        self.left: TreeNode | None = None  # \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n        self.right: TreeNode | None = None # \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\n    int val;          // \u8282\u70b9\u503c\n    TreeNode *left;   // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    TreeNode *right;  // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n};\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    int val;         // \u8282\u70b9\u503c\n    TreeNode left;   // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    TreeNode right;  // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n    TreeNode(int x) { val = x; }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode(int? x) {\n    public int? val = x;    // \u8282\u70b9\u503c\n    public TreeNode? left;  // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    public TreeNode? right; // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntype TreeNode struct {\n    Val   int\n    Left  *TreeNode\n    Right *TreeNode\n}\n/* \u6784\u9020\u65b9\u6cd5 */\nfunc NewTreeNode(v int) *TreeNode {\n    return &TreeNode{\n        Left:  nil, // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n        Right: nil, // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n        Val:   v,   // \u8282\u70b9\u503c\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    var val: Int // \u8282\u70b9\u503c\n    var left: TreeNode? // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    var right: TreeNode? // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n\n    init(x: Int) {\n        val = x\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    val; // \u8282\u70b9\u503c\n    left; // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n    constructor(val, left, right) {\n        this.val = val === undefined ? 0 : val;\n        this.left = left === undefined ? null : left;\n        this.right = right === undefined ? null : right;\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n    val: number;\n    left: TreeNode | null;\n    right: TreeNode | null;\n\n    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {\n        this.val = val === undefined ? 0 : val; // \u8282\u70b9\u503c\n        this.left = left === undefined ? null : left; // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n        this.right = right === undefined ? null : right; // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode {\n  int val;         // \u8282\u70b9\u503c\n  TreeNode? left;  // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n  TreeNode? right; // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n  TreeNode(this.val, [this.left, this.right]);\n}\n
    use std::rc::Rc;\nuse std::cell::RefCell;\n\n/* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\nstruct TreeNode {\n    val: i32,                               // \u8282\u70b9\u503c\n    left: Option<Rc<RefCell<TreeNode>>>,    // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    right: Option<Rc<RefCell<TreeNode>>>,   // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n\nimpl TreeNode {\n    /* \u6784\u9020\u65b9\u6cd5 */\n    fn new(val: i32) -> Rc<RefCell<Self>> {\n        Rc::new(RefCell::new(Self {\n            val,\n            left: None,\n            right: None\n        }))\n    }\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7ed3\u6784\u4f53 */\ntypedef struct TreeNode {\n    int val;                // \u8282\u70b9\u503c\n    int height;             // \u8282\u70b9\u9ad8\u5ea6\n    struct TreeNode *left;  // \u5de6\u5b50\u8282\u70b9\u6307\u9488\n    struct TreeNode *right; // \u53f3\u5b50\u8282\u70b9\u6307\u9488\n} TreeNode;\n\n/* \u6784\u9020\u51fd\u6570 */\nTreeNode *newTreeNode(int val) {\n    TreeNode *node;\n\n    node = (TreeNode *)malloc(sizeof(TreeNode));\n    node->val = val;\n    node->height = 0;\n    node->left = NULL;\n    node->right = NULL;\n    return node;\n}\n
    /* \u4e8c\u53c9\u6811\u8282\u70b9\u7c7b */\nclass TreeNode(val _val: Int) {  // \u8282\u70b9\u503c\n    val left: TreeNode? = null   // \u5de6\u5b50\u8282\u70b9\u5f15\u7528\n    val right: TreeNode? = null  // \u53f3\u5b50\u8282\u70b9\u5f15\u7528\n}\n
    \n
    \n

    \u6bcf\u4e2a\u8282\u70b9\u90fd\u6709\u4e24\u4e2a\u5f15\u7528\uff08\u6307\u9488\uff09\uff0c\u5206\u522b\u6307\u5411\u300c\u5de6\u5b50\u8282\u70b9 left-child node\u300d\u548c\u300c\u53f3\u5b50\u8282\u70b9 right-child node\u300d\uff0c\u8be5\u8282\u70b9\u88ab\u79f0\u4e3a\u8fd9\u4e24\u4e2a\u5b50\u8282\u70b9\u7684\u300c\u7236\u8282\u70b9 parent node\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 left subtree\u300d\uff0c\u540c\u7406\u53ef\u5f97\u300c\u53f3\u5b50\u6811 right subtree\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\u5982\u56fe 7-1 \u6240\u793a\uff0c\u5982\u679c\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

    \u56fe 7-1 \u00a0 \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\u7684\u5e38\u7528\u672f\u8bed\u5982\u56fe 7-2 \u6240\u793a\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\u3002
    • \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 None \u3002
    • \u300c\u8fb9 edge\u300d\uff1a\u8fde\u63a5\u4e24\u4e2a\u8282\u70b9\u7684\u7ebf\u6bb5\uff0c\u5373\u8282\u70b9\u5f15\u7528\uff08\u6307\u9488\uff09\u3002
    • \u8282\u70b9\u6240\u5728\u7684\u300c\u5c42 level\u300d\uff1a\u4ece\u9876\u81f3\u5e95\u9012\u589e\uff0c\u6839\u8282\u70b9\u6240\u5728\u5c42\u4e3a 1 \u3002
    • \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\u53d6\u503c\u8303\u56f4\u662f 0\u30011\u30012 \u3002
    • \u4e8c\u53c9\u6811\u7684\u300c\u9ad8\u5ea6 height\u300d\uff1a\u4ece\u6839\u8282\u70b9\u5230\u6700\u8fdc\u53f6\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\u3002
    • \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\u3002
    • \u8282\u70b9\u7684\u300c\u9ad8\u5ea6 height\u300d\uff1a\u4ece\u8ddd\u79bb\u8be5\u8282\u70b9\u6700\u8fdc\u7684\u53f6\u8282\u70b9\u5230\u8be5\u8282\u70b9\u6240\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\u3002

    \u56fe 7-2 \u00a0 \u4e8c\u53c9\u6811\u7684\u5e38\u7528\u672f\u8bed

    Tip

    \u8bf7\u6ce8\u610f\uff0c\u6211\u4eec\u901a\u5e38\u5c06\u201c\u9ad8\u5ea6\u201d\u548c\u201c\u6df1\u5ea6\u201d\u5b9a\u4e49\u4e3a\u201c\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\u201d\uff0c\u4f46\u6709\u4e9b\u9898\u76ee\u6216\u6559\u6750\u53ef\u80fd\u4f1a\u5c06\u5176\u5b9a\u4e49\u4e3a\u201c\u7ecf\u8fc7\u7684\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":""},{"location":"chapter_tree/binary_tree/#1","title":"1. \u00a0 \u521d\u59cb\u5316\u4e8c\u53c9\u6811","text":"

    \u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u9996\u5148\u521d\u59cb\u5316\u8282\u70b9\uff0c\u7136\u540e\u6784\u5efa\u5f15\u7528\uff08\u6307\u9488\uff09\u3002

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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(1);\nTreeNode n2 = new(2);\nTreeNode n3 = new(3);\nTreeNode n4 = new(4);\nTreeNode n5 = new(5);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\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),\n    n2 = new TreeNode(2),\n    n3 = new TreeNode(3),\n    n4 = new TreeNode(4),\n    n5 = new TreeNode(5);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1.left = n2;\nn1.right = n3;\nn2.left = n4;\nn2.right = n5;\n
    binary_tree.rs
    // \u521d\u59cb\u5316\u8282\u70b9\nlet n1 = TreeNode::new(1);\nlet n2 = TreeNode::new(2);\nlet n3 = TreeNode::new(3);\nlet n4 = TreeNode::new(4);\nlet n5 = TreeNode::new(5);\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1.borrow_mut().left = Some(n2.clone());\nn1.borrow_mut().right = Some(n3);\nn2.borrow_mut().left = Some(n4);\nn2.borrow_mut().right = Some(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\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1->left = n2;\nn1->right = n3;\nn2->left = n4;\nn2->right = n5;\n
    binary_tree.kt
    // \u521d\u59cb\u5316\u8282\u70b9\nval n1 = TreeNode(1)\nval n2 = TreeNode(2)\nval n3 = TreeNode(3)\nval n4 = TreeNode(4)\nval n5 = TreeNode(5)\n// \u6784\u5efa\u8282\u70b9\u4e4b\u95f4\u7684\u5f15\u7528\uff08\u6307\u9488\uff09\nn1.left = n2\nn1.right = n3\nn2.left = n4\nn2.right = n5\n
    binary_tree.rb
    \n
    binary_tree.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/binary_tree/#2","title":"2. \u00a0 \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9","text":"

    \u4e0e\u94fe\u8868\u7c7b\u4f3c\uff0c\u5728\u4e8c\u53c9\u6811\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9\u53ef\u4ee5\u901a\u8fc7\u4fee\u6539\u6307\u9488\u6765\u5b9e\u73b0\u3002\u56fe 7-3 \u7ed9\u51fa\u4e86\u4e00\u4e2a\u793a\u4f8b\u3002

    \u56fe 7-3 \u00a0 \u5728\u4e8c\u53c9\u6811\u4e2d\u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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.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.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.cs
    /* \u63d2\u5165\u4e0e\u5220\u9664\u8282\u70b9 */\nTreeNode P = new(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.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.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.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
    binary_tree.rs
    let p = TreeNode::new(0);\n// \u5728 n1 -> n2 \u4e2d\u95f4\u63d2\u5165\u8282\u70b9 P\nn1.borrow_mut().left = Some(p.clone());\np.borrow_mut().left = Some(n2.clone());\n// \u5220\u9664\u8282\u70b9 p\nn1.borrow_mut().left = Some(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.kt
    val P = 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.rb
    \n
    binary_tree.zig
    \n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    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\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_1","title":"1. \u00a0 \u5b8c\u7f8e\u4e8c\u53c9\u6811","text":"

    \u5982\u56fe 7-4 \u6240\u793a\uff0c\u300c\u5b8c\u7f8e\u4e8c\u53c9\u6811 perfect binary tree\u300d\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\u7684\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

    \u8bf7\u6ce8\u610f\uff0c\u5728\u4e2d\u6587\u793e\u533a\u4e2d\uff0c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u5e38\u88ab\u79f0\u4e3a\u300c\u6ee1\u4e8c\u53c9\u6811\u300d\u3002

    \u56fe 7-4 \u00a0 \u5b8c\u7f8e\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#2_1","title":"2. \u00a0 \u5b8c\u5168\u4e8c\u53c9\u6811","text":"

    \u5982\u56fe 7-5 \u6240\u793a\uff0c\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

    \u56fe 7-5 \u00a0 \u5b8c\u5168\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#3","title":"3. \u00a0 \u5b8c\u6ee1\u4e8c\u53c9\u6811","text":"

    \u5982\u56fe 7-6 \u6240\u793a\uff0c\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

    \u56fe 7-6 \u00a0 \u5b8c\u6ee1\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#4","title":"4. \u00a0 \u5e73\u8861\u4e8c\u53c9\u6811","text":"

    \u5982\u56fe 7-7 \u6240\u793a\uff0c\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

    \u56fe 7-7 \u00a0 \u5e73\u8861\u4e8c\u53c9\u6811

    "},{"location":"chapter_tree/binary_tree/#714","title":"7.1.4 \u00a0 \u4e8c\u53c9\u6811\u7684\u9000\u5316","text":"

    \u56fe 7-8 \u5c55\u793a\u4e86\u4e8c\u53c9\u6811\u7684\u7406\u60f3\u7ed3\u6784\u4e0e\u9000\u5316\u7ed3\u6784\u3002\u5f53\u4e8c\u53c9\u6811\u7684\u6bcf\u5c42\u8282\u70b9\u90fd\u88ab\u586b\u6ee1\u65f6\uff0c\u8fbe\u5230\u201c\u5b8c\u7f8e\u4e8c\u53c9\u6811\u201d\uff1b\u800c\u5f53\u6240\u6709\u8282\u70b9\u90fd\u504f\u5411\u4e00\u4fa7\u65f6\uff0c\u4e8c\u53c9\u6811\u9000\u5316\u4e3a\u201c\u94fe\u8868\u201d\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\u3002
    • \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)\\) \u3002

    \u56fe 7-8 \u00a0 \u4e8c\u53c9\u6811\u7684\u6700\u4f73\u7ed3\u6784\u4e0e\u6700\u5dee\u7ed3\u6784

    \u5982\u8868 7-1 \u6240\u793a\uff0c\u5728\u6700\u4f73\u7ed3\u6784\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\u503c\u6216\u6781\u5c0f\u503c\u3002

    \u8868 7-1 \u00a0 \u4e8c\u53c9\u6811\u7684\u6700\u4f73\u7ed3\u6784\u4e0e\u6700\u5dee\u7ed3\u6784

    \u5b8c\u7f8e\u4e8c\u53c9\u6811 \u94fe\u8868 \u7b2c \\(i\\) \u5c42\u7684\u8282\u70b9\u6570\u91cf \\(2^{i-1}\\) \\(1\\) \u9ad8\u5ea6\u4e3a \\(h\\) \u7684\u6811\u7684\u53f6\u8282\u70b9\u6570\u91cf \\(2^h\\) \\(1\\) \u9ad8\u5ea6\u4e3a \\(h\\) \u7684\u6811\u7684\u8282\u70b9\u603b\u6570 \\(2^{h+1} - 1\\) \\(h + 1\\) \u8282\u70b9\u603b\u6570\u4e3a \\(n\\) \u7684\u6811\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":"

    \u5982\u56fe 7-9 \u6240\u793a\uff0c\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\u904d\u5386 breadth-first traversal\u300d\uff0c\u4e5f\u79f0\u300c\u5e7f\u5ea6\u4f18\u5148\u641c\u7d22 breadth-first search, BFS\u300d\uff0c\u5b83\u4f53\u73b0\u4e86\u4e00\u79cd\u201c\u4e00\u5708\u4e00\u5708\u5411\u5916\u6269\u5c55\u201d\u7684\u9010\u5c42\u904d\u5386\u65b9\u5f0f\u3002

    \u56fe 7-9 \u00a0 \u4e8c\u53c9\u6811\u7684\u5c42\u5e8f\u904d\u5386

    "},{"location":"chapter_tree/binary_tree_traversal/#1","title":"1. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u901a\u5e38\u501f\u52a9\u201c\u961f\u5217\u201d\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\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig 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\n    queue: deque[TreeNode] = deque()\n    queue.append(root)\n    # \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    res = []\n    while queue:\n        node: TreeNode = queue.popleft()  # \u961f\u5217\u51fa\u961f\n        res.append(node.val)  # \u4fdd\u5b58\u8282\u70b9\u503c\n        if node.left is not None:\n            queue.append(node.left)  # \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if node.right is not None:\n            queue.append(node.right)  # \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    return res\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\n    queue<TreeNode *> queue;\n    queue.push(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    vector<int> vec;\n    while (!queue.empty()) {\n        TreeNode *node = queue.front();\n        queue.pop();              // \u961f\u5217\u51fa\u961f\n        vec.push_back(node->val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node->left != nullptr)\n            queue.push(node->left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node->right != nullptr)\n            queue.push(node->right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return vec;\n}\n
    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\n    Queue<TreeNode> queue = new LinkedList<>();\n    queue.add(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    List<Integer> list = new ArrayList<>();\n    while (!queue.isEmpty()) {\n        TreeNode node = queue.poll(); // \u961f\u5217\u51fa\u961f\n        list.add(node.val);           // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null)\n            queue.offer(node.left);   // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right != null)\n            queue.offer(node.right);  // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list;\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\n    Queue<TreeNode> queue = new();\n    queue.Enqueue(root);\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    List<int> list = [];\n    while (queue.Count != 0) {\n        TreeNode node = queue.Dequeue(); // \u961f\u5217\u51fa\u961f\n        list.Add(node.val!.Value);       // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null)\n            queue.Enqueue(node.left);    // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right != null)\n            queue.Enqueue(node.right);   // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list;\n}\n
    binary_tree_bfs.go
    /* \u5c42\u5e8f\u904d\u5386 */\nfunc levelOrder(root *TreeNode) []any {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    queue := list.New()\n    queue.PushBack(root)\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5207\u7247\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    nums := make([]any, 0)\n    for queue.Len() > 0 {\n        // \u961f\u5217\u51fa\u961f\n        node := queue.Remove(queue.Front()).(*TreeNode)\n        // \u4fdd\u5b58\u8282\u70b9\u503c\n        nums = append(nums, node.Val)\n        if node.Left != nil {\n            // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n            queue.PushBack(node.Left)\n        }\n        if node.Right != nil {\n            // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n            queue.PushBack(node.Right)\n        }\n    }\n    return nums\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\n    var queue: [TreeNode] = [root]\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    var list: [Int] = []\n    while !queue.isEmpty {\n        let node = queue.removeFirst() // \u961f\u5217\u51fa\u961f\n        list.append(node.val) // \u4fdd\u5b58\u8282\u70b9\u503c\n        if let left = node.left {\n            queue.append(left) // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if let right = node.right {\n            queue.append(right) // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }\n    }\n    return list\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\n    const queue = [root];\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    const list = [];\n    while (queue.length) {\n        let node = queue.shift(); // \u961f\u5217\u51fa\u961f\n        list.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left) queue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        if (node.right) queue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return 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\n    const queue = [root];\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    const list: number[] = [];\n    while (queue.length) {\n        let node = queue.shift() as TreeNode; // \u961f\u5217\u51fa\u961f\n        list.push(node.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left) {\n            queue.push(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if (node.right) {\n            queue.push(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }\n    }\n    return 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\n  Queue<TreeNode?> queue = Queue();\n  queue.add(root);\n  // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n  List<int> res = [];\n  while (queue.isNotEmpty) {\n    TreeNode? node = queue.removeFirst(); // \u961f\u5217\u51fa\u961f\n    res.add(node!.val); // \u4fdd\u5b58\u8282\u70b9\u503c\n    if (node.left != null) queue.add(node.left); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n    if (node.right != null) queue.add(node.right); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n  }\n  return res;\n}\n
    binary_tree_bfs.rs
    /* \u5c42\u5e8f\u904d\u5386 */\nfn level_order(root: &Rc<RefCell<TreeNode>>) -> Vec<i32> {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    let mut que = VecDeque::new();\n    que.push_back(Rc::clone(&root));\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    let mut vec = Vec::new();\n\n    while let Some(node) = que.pop_front() {\n        // \u961f\u5217\u51fa\u961f\n        vec.push(node.borrow().val); // \u4fdd\u5b58\u8282\u70b9\u503c\n        if let Some(left) = node.borrow().left.as_ref() {\n            que.push_back(Rc::clone(left)); // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if let Some(right) = node.borrow().right.as_ref() {\n            que.push_back(Rc::clone(right)); // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        };\n    }\n    vec\n}\n
    binary_tree_bfs.c
    /* \u5c42\u5e8f\u904d\u5386 */\nint *levelOrder(TreeNode *root, int *size) {\n    /* \u8f85\u52a9\u961f\u5217 */\n    int front, rear;\n    int index, *arr;\n    TreeNode *node;\n    TreeNode **queue;\n\n    /* \u8f85\u52a9\u961f\u5217 */\n    queue = (TreeNode **)malloc(sizeof(TreeNode *) * MAX_SIZE);\n    // \u961f\u5217\u6307\u9488\n    front = 0, rear = 0;\n    // \u52a0\u5165\u6839\u8282\u70b9\n    queue[rear++] = root;\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    /* \u8f85\u52a9\u6570\u7ec4 */\n    arr = (int *)malloc(sizeof(int) * MAX_SIZE);\n    // \u6570\u7ec4\u6307\u9488\n    index = 0;\n    while (front < rear) {\n        // \u961f\u5217\u51fa\u961f\n        node = queue[front++];\n        // \u4fdd\u5b58\u8282\u70b9\u503c\n        arr[index++] = node->val;\n        if (node->left != NULL) {\n            // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n            queue[rear++] = node->left;\n        }\n        if (node->right != NULL) {\n            // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n            queue[rear++] = node->right;\n        }\n    }\n    // \u66f4\u65b0\u6570\u7ec4\u957f\u5ea6\u7684\u503c\n    *size = index;\n    arr = realloc(arr, sizeof(int) * (*size));\n\n    // \u91ca\u653e\u8f85\u52a9\u6570\u7ec4\u7a7a\u95f4\n    free(queue);\n    return arr;\n}\n
    binary_tree_bfs.kt
    /* \u5c42\u5e8f\u904d\u5386 */\nfun levelOrder(root: TreeNode?): MutableList<Int> {\n    // \u521d\u59cb\u5316\u961f\u5217\uff0c\u52a0\u5165\u6839\u8282\u70b9\n    val queue = LinkedList<TreeNode?>()\n    queue.add(root)\n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    val list = ArrayList<Int>()\n    while (!queue.isEmpty()) {\n        val node = queue.poll() // \u961f\u5217\u51fa\u961f\n        list.add(node?.value!!) // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null) queue.offer(node.left) // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n\n        if (node.right != null) queue.offer(node.right) // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n    }\n    return list\n}\n
    binary_tree_bfs.rb
    [class]{}-[func]{level_order}\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\n    const L = std.TailQueue(*inc.TreeNode(T));\n    var queue = L{};\n    var root_node = try mem_allocator.create(L.Node);\n    root_node.data = root;\n    queue.append(root_node); \n    // \u521d\u59cb\u5316\u4e00\u4e2a\u5217\u8868\uff0c\u7528\u4e8e\u4fdd\u5b58\u904d\u5386\u5e8f\u5217\n    var list = std.ArrayList(T).init(std.heap.page_allocator);\n    while (queue.len > 0) {\n        var queue_node = queue.popFirst().?;    // \u961f\u5217\u51fa\u961f\n        var node = queue_node.data;\n        try list.append(node.val);              // \u4fdd\u5b58\u8282\u70b9\u503c\n        if (node.left != null) {\n            var tmp_node = try mem_allocator.create(L.Node);\n            tmp_node.data = node.left.?;\n            queue.append(tmp_node);             // \u5de6\u5b50\u8282\u70b9\u5165\u961f\n        }\n        if (node.right != null) {\n            var tmp_node = try mem_allocator.create(L.Node);\n            tmp_node.data = node.right.?;\n            queue.append(tmp_node);             // \u53f3\u5b50\u8282\u70b9\u5165\u961f\n        }        \n    }\n    return list;\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    "},{"location":"chapter_tree/binary_tree_traversal/#2","title":"2. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \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\u4e3a \\(O(n)\\) \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 \\((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\u4e5f\u79f0\u300c\u6df1\u5ea6\u4f18\u5148\u641c\u7d22 depth-first search, DFS\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

    \u56fe 7-10 \u5c55\u793a\u4e86\u5bf9\u4e8c\u53c9\u6811\u8fdb\u884c\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u7684\u5de5\u4f5c\u539f\u7406\u3002\u6df1\u5ea6\u4f18\u5148\u904d\u5386\u5c31\u50cf\u662f\u7ed5\u7740\u6574\u68f5\u4e8c\u53c9\u6811\u7684\u5916\u56f4\u201c\u8d70\u201d\u4e00\u5708\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

    \u56fe 7-10 \u00a0 \u4e8c\u53c9\u641c\u7d22\u6811\u7684\u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386

    "},{"location":"chapter_tree/binary_tree_traversal/#1_1","title":"1. \u00a0 \u4ee3\u7801\u5b9e\u73b0","text":"

    \u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u901a\u5e38\u57fa\u4e8e\u9012\u5f52\u5b9e\u73b0\uff1a

    PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig binary_tree_dfs.py
    def pre_order(root: TreeNode | None):\n    \"\"\"\u524d\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    res.append(root.val)\n    pre_order(root=root.left)\n    pre_order(root=root.right)\n\ndef in_order(root: TreeNode | None):\n    \"\"\"\u4e2d\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    in_order(root=root.left)\n    res.append(root.val)\n    in_order(root=root.right)\n\ndef post_order(root: TreeNode | None):\n    \"\"\"\u540e\u5e8f\u904d\u5386\"\"\"\n    if root is None:\n        return\n    # \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    post_order(root=root.left)\n    post_order(root=root.right)\n    res.append(root.val)\n
    binary_tree_dfs.cpp
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    vec.push_back(root->val);\n    preOrder(root->left);\n    preOrder(root->right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root->left);\n    vec.push_back(root->val);\n    inOrder(root->right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root) {\n    if (root == nullptr)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root->left);\n    postOrder(root->right);\n    vec.push_back(root->val);\n}\n
    binary_tree_dfs.java
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.add(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.add(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode root) {\n    if (root == null)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.add(root.val);\n}\n
    binary_tree_dfs.cs
    /* \u524d\u5e8f\u904d\u5386 */\nvoid PreOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.Add(root.val!.Value);\n    PreOrder(root.left);\n    PreOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid InOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    InOrder(root.left);\n    list.Add(root.val!.Value);\n    InOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid PostOrder(TreeNode? root) {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    PostOrder(root.left);\n    PostOrder(root.right);\n    list.Add(root.val!.Value);\n}\n
    binary_tree_dfs.go
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    nums = append(nums, node.Val)\n    preOrder(node.Left)\n    preOrder(node.Right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(node.Left)\n    nums = append(nums, node.Val)\n    inOrder(node.Right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(node *TreeNode) {\n    if node == nil {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(node.Left)\n    postOrder(node.Right)\n    nums = append(nums, node.Val)\n}\n
    binary_tree_dfs.swift
    /* \u524d\u5e8f\u904d\u5386 */\nfunc preOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.append(root.val)\n    preOrder(root: root.left)\n    preOrder(root: root.right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunc inOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root: root.left)\n    list.append(root.val)\n    inOrder(root: root.right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunc postOrder(root: TreeNode?) {\n    guard let root = root else {\n        return\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root: root.left)\n    postOrder(root: root.right)\n    list.append(root.val)\n}\n
    binary_tree_dfs.js
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root) {\n    if (root === null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n
    binary_tree_dfs.ts
    /* \u524d\u5e8f\u904d\u5386 */\nfunction preOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.push(root.val);\n    preOrder(root.left);\n    preOrder(root.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfunction inOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left);\n    list.push(root.val);\n    inOrder(root.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfunction postOrder(root: TreeNode | null): void {\n    if (root === null) {\n        return;\n    }\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left);\n    postOrder(root.right);\n    list.push(root.val);\n}\n
    binary_tree_dfs.dart
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n  list.add(node.val);\n  preOrder(node.left);\n  preOrder(node.right);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n  inOrder(node.left);\n  list.add(node.val);\n  inOrder(node.right);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode? node) {\n  if (node == null) return;\n  // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n  postOrder(node.left);\n  postOrder(node.right);\n  list.add(node.val);\n}\n
    binary_tree_dfs.rs
    /* \u524d\u5e8f\u904d\u5386 */\nfn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n        result.push(node.borrow().val);\n        result.append(&mut pre_order(node.borrow().left.as_ref()));\n        result.append(&mut pre_order(node.borrow().right.as_ref()));\n    }\n    result\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n        result.append(&mut in_order(node.borrow().left.as_ref()));\n        result.push(node.borrow().val);\n        result.append(&mut in_order(node.borrow().right.as_ref()));\n    }\n    result\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {\n    let mut result = vec![];\n\n    if let Some(node) = root {\n        // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n        result.append(&mut post_order(node.borrow().left.as_ref()));\n        result.append(&mut post_order(node.borrow().right.as_ref()));\n        result.push(node.borrow().val);\n    }\n    result\n}\n
    binary_tree_dfs.c
    /* \u524d\u5e8f\u904d\u5386 */\nvoid preOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    arr[(*size)++] = root->val;\n    preOrder(root->left, size);\n    preOrder(root->right, size);\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nvoid inOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root->left, size);\n    arr[(*size)++] = root->val;\n    inOrder(root->right, size);\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nvoid postOrder(TreeNode *root, int *size) {\n    if (root == NULL)\n        return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root->left, size);\n    postOrder(root->right, size);\n    arr[(*size)++] = root->val;\n}\n
    binary_tree_dfs.kt
    /* \u524d\u5e8f\u904d\u5386 */\nfun preOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    list.add(root.value)\n    preOrder(root.left)\n    preOrder(root.right)\n}\n\n/* \u4e2d\u5e8f\u904d\u5386 */\nfun inOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    inOrder(root.left)\n    list.add(root.value)\n    inOrder(root.right)\n}\n\n/* \u540e\u5e8f\u904d\u5386 */\nfun postOrder(root: TreeNode?) {\n    if (root == null) return\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    postOrder(root.left)\n    postOrder(root.right)\n    list.add(root.value)\n}\n
    binary_tree_dfs.rb
    [class]{}-[func]{pre_order}\n\n[class]{}-[func]{in_order}\n\n[class]{}-[func]{post_order}\n
    binary_tree_dfs.zig
    // \u524d\u5e8f\u904d\u5386\nfn preOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u6839\u8282\u70b9 -> \u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811\n    try list.append(root.?.val);\n    try preOrder(T, root.?.left);\n    try preOrder(T, root.?.right);\n}\n\n// \u4e2d\u5e8f\u904d\u5386\nfn inOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u6839\u8282\u70b9 -> \u53f3\u5b50\u6811\n    try inOrder(T, root.?.left);\n    try list.append(root.?.val);\n    try inOrder(T, root.?.right);\n}\n\n// \u540e\u5e8f\u904d\u5386\nfn postOrder(comptime T: type, root: ?*inc.TreeNode(T)) !void {\n    if (root == null) return;\n    // \u8bbf\u95ee\u4f18\u5148\u7ea7\uff1a\u5de6\u5b50\u6811 -> \u53f3\u5b50\u6811 -> \u6839\u8282\u70b9\n    try postOrder(T, root.?.left);\n    try postOrder(T, root.?.right);\n    try list.append(root.?.val);\n}\n
    \u53ef\u89c6\u5316\u8fd0\u884c

    \u5168\u5c4f\u89c2\u770b >

    Tip

    \u6df1\u5ea6\u4f18\u5148\u641c\u7d22\u4e5f\u53ef\u4ee5\u57fa\u4e8e\u8fed\u4ee3\u5b9e\u73b0\uff0c\u6709\u5174\u8da3\u7684\u8bfb\u8005\u53ef\u4ee5\u81ea\u884c\u7814\u7a76\u3002

    \u56fe 7-11 \u5c55\u793a\u4e86\u524d\u5e8f\u904d\u5386\u4e8c\u53c9\u6811\u7684\u9012\u5f52\u8fc7\u7a0b\uff0c\u5176\u53ef\u5206\u4e3a\u201c\u9012\u201d\u548c\u201c\u5f52\u201d\u4e24\u4e2a\u9006\u5411\u7684\u90e8\u5206\u3002

    1. \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\u3002
    2. \u201c\u5f52\u201d\u8868\u793a\u51fd\u6570\u8fd4\u56de\uff0c\u4ee3\u8868\u5f53\u524d\u8282\u70b9\u5df2\u7ecf\u8bbf\u95ee\u5b8c\u6bd5\u3002
    <1><2><3><4><5><6><7><8><9><10><11>

    \u56fe 7-11 \u00a0 \u524d\u5e8f\u904d\u5386\u7684\u9012\u5f52\u8fc7\u7a0b

    "},{"location":"chapter_tree/binary_tree_traversal/#2_1","title":"2. \u00a0 \u590d\u6742\u5ea6\u5206\u6790","text":"
    • \u65f6\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \uff1a\u6240\u6709\u8282\u70b9\u88ab\u8bbf\u95ee\u4e00\u6b21\uff0c\u4f7f\u7528 \\(O(n)\\) \u65f6\u95f4\u3002
    • \u7a7a\u95f4\u590d\u6742\u5ea6\u4e3a \\(O(n)\\) \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":""},{"location":"chapter_tree/summary/#1","title":"1. \u00a0 \u91cd\u70b9\u56de\u987e","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\u5b8c\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\u6269\u5c55\u201d\u7684\u9010\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\u5148\u8d70\u5230\u5c3d\u5934\uff0c\u518d\u56de\u6eaf\u7ee7\u7eed\u201d\u7684\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\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\u5b83\u901a\u8fc7\u65cb\u8f6c\u64cd\u4f5c\u786e\u4fdd\u5728\u4e0d\u65ad\u63d2\u5165\u548c\u5220\u9664\u8282\u70b9\u540e\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/#2-q-a","title":"2. \u00a0 Q & A","text":"

    Q\uff1a\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\u7ecf\u8fc7\u7684\u8fb9\u7684\u6570\u91cf\u201d\u3002

    Q\uff1a\u4e8c\u53c9\u6811\u4e2d\u7684\u63d2\u5165\u4e0e\u5220\u9664\u4e00\u822c\u7531\u4e00\u5957\u64cd\u4f5c\u914d\u5408\u5b8c\u6210\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\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

    Q\uff1a\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

    \u4e0e\u987a\u5e8f\u548c\u9006\u5e8f\u904d\u5386\u6570\u7ec4\u7c7b\u4f3c\uff0c\u524d\u5e8f\u3001\u4e2d\u5e8f\u3001\u540e\u5e8f\u904d\u5386\u662f\u4e09\u79cd\u4e8c\u53c9\u6811\u904d\u5386\u65b9\u6cd5\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u5b83\u4eec\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\u8282\u70b9\u5927\u5c0f\u6ee1\u8db3 \u5de6\u5b50\u8282\u70b9\u503c < \u6839\u8282\u70b9\u503c < \u53f3\u5b50\u8282\u70b9\u503c \uff0c\u56e0\u6b64\u6211\u4eec\u53ea\u8981\u6309\u7167\u201c\u5de6 \\(\\rightarrow\\) \u6839 \\(\\rightarrow\\) \u53f3\u201d\u7684\u4f18\u5148\u7ea7\u904d\u5386\u6811\uff0c\u5c31\u53ef\u4ee5\u83b7\u5f97\u6709\u5e8f\u7684\u8282\u70b9\u5e8f\u5217\u3002

    Q\uff1a\u53f3\u65cb\u64cd\u4f5c\u662f\u5904\u7406\u5931\u8861\u8282\u70b9 node\u3001child\u3001grand_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

    Q\uff1a\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\u8282\u70b9\u9ad8\u5ea6\uff0c\u7c7b\u4f3c\u4e8e vector.size() \uff0c\u56e0\u6b64\u8bbe\u7f6e\u6210 public \u4ee5\u4fbf\u4f7f\u7528\u3002

    Q\uff1a\u5982\u4f55\u4ece\u4e00\u7ec4\u8f93\u5165\u6570\u636e\u6784\u5efa\u4e00\u68f5\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\u5df2\u5728\u4e8c\u53c9\u641c\u7d22\u6811\u4ee3\u7801\u4e2d\u7684 build_tree() \u65b9\u6cd5\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\u5c06\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

    Q\uff1a\u5728 Java \u4e2d\uff0c\u5b57\u7b26\u4e32\u5bf9\u6bd4\u662f\u5426\u4e00\u5b9a\u8981\u7528 equals() \u65b9\u6cd5\uff1f

    \u5728 Java \u4e2d\uff0c\u5bf9\u4e8e\u57fa\u672c\u6570\u636e\u7c7b\u578b\uff0c== \u7528\u4e8e\u5bf9\u6bd4\u4e24\u4e2a\u53d8\u91cf\u7684\u503c\u662f\u5426\u76f8\u7b49\u3002\u5bf9\u4e8e\u5f15\u7528\u7c7b\u578b\uff0c\u4e24\u79cd\u7b26\u53f7\u7684\u5de5\u4f5c\u539f\u7406\u662f\u4e0d\u540c\u7684\u3002

    • == \uff1a\u7528\u6765\u6bd4\u8f83\u4e24\u4e2a\u53d8\u91cf\u662f\u5426\u6307\u5411\u540c\u4e00\u4e2a\u5bf9\u8c61\uff0c\u5373\u5b83\u4eec\u5728\u5185\u5b58\u4e2d\u7684\u4f4d\u7f6e\u662f\u5426\u76f8\u540c\u3002
    • equals()\uff1a\u7528\u6765\u5bf9\u6bd4\u4e24\u4e2a\u5bf9\u8c61\u7684\u503c\u662f\u5426\u76f8\u7b49\u3002

    \u56e0\u6b64\uff0c\u5982\u679c\u8981\u5bf9\u6bd4\u503c\uff0c\u6211\u4eec\u5e94\u8be5\u4f7f\u7528 equals() \u3002\u7136\u800c\uff0c\u901a\u8fc7 String a = \"hi\"; String b = \"hi\"; \u521d\u59cb\u5316\u7684\u5b57\u7b26\u4e32\u90fd\u5b58\u50a8\u5728\u5b57\u7b26\u4e32\u5e38\u91cf\u6c60\u4e2d\uff0c\u5b83\u4eec\u6307\u5411\u540c\u4e00\u4e2a\u5bf9\u8c61\uff0c\u56e0\u6b64\u4e5f\u53ef\u4ee5\u7528 a == b \u6765\u6bd4\u8f83\u4e24\u4e2a\u5b57\u7b26\u4e32\u7684\u5185\u5bb9\u3002

    Q\uff1a\u5e7f\u5ea6\u4f18\u5148\u904d\u5386\u5230\u6700\u5e95\u5c42\u4e4b\u524d\uff0c\u961f\u5217\u4e2d\u7684\u8282\u70b9\u6570\u91cf\u662f \\(2^h\\) \u5417\uff1f

    \u662f\u7684\uff0c\u4f8b\u5982\u9ad8\u5ea6 \\(h = 2\\) \u7684\u6ee1\u4e8c\u53c9\u6811\uff0c\u5176\u8282\u70b9\u603b\u6570 \\(n = 7\\) \uff0c\u5219\u5e95\u5c42\u8282\u70b9\u6570\u91cf \\(4 = 2^h = (n + 1) / 2\\) \u3002

    "}]} \ No newline at end of file diff --git a/sitemap.xml b/sitemap.xml index 84117232c..f025427fb 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -2,527 +2,527 @@ https://www.hello-algo.com/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_appendix/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_appendix/contribution/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_appendix/installation/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_appendix/terminology/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_array_and_linkedlist/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_array_and_linkedlist/array/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_array_and_linkedlist/linked_list/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_array_and_linkedlist/list/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_array_and_linkedlist/ram_and_cache/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_array_and_linkedlist/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_backtracking/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_backtracking/backtracking_algorithm/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_backtracking/n_queens_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_backtracking/permutations_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_backtracking/subset_sum_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_backtracking/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_computational_complexity/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_computational_complexity/iteration_and_recursion/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_computational_complexity/performance_evaluation/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_computational_complexity/space_complexity/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_computational_complexity/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_computational_complexity/time_complexity/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_data_structure/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_data_structure/basic_data_types/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_data_structure/character_encoding/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_data_structure/classification_of_data_structure/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_data_structure/number_encoding/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_data_structure/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_divide_and_conquer/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_divide_and_conquer/binary_search_recur/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_divide_and_conquer/build_binary_tree_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_divide_and_conquer/divide_and_conquer/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_divide_and_conquer/hanota_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_divide_and_conquer/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_dynamic_programming/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_dynamic_programming/dp_problem_features/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_dynamic_programming/dp_solution_pipeline/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_dynamic_programming/edit_distance_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_dynamic_programming/intro_to_dynamic_programming/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_dynamic_programming/knapsack_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_dynamic_programming/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_dynamic_programming/unbounded_knapsack_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_graph/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_graph/graph/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_graph/graph_operations/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_graph/graph_traversal/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_graph/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_greedy/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_greedy/fractional_knapsack_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_greedy/greedy_algorithm/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_greedy/max_capacity_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_greedy/max_product_cutting_problem/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_greedy/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_hashing/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_hashing/hash_algorithm/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_hashing/hash_collision/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_hashing/hash_map/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_hashing/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_heap/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_heap/build_heap/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_heap/heap/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_heap/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_heap/top_k/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_introduction/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_introduction/algorithms_are_everywhere/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_introduction/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_introduction/what_is_dsa/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_paperbook/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_preface/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_preface/about_the_book/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_preface/suggestions/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_preface/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_reference/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_searching/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_searching/binary_search/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_searching/binary_search_edge/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_searching/binary_search_insertion/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_searching/replace_linear_by_hashing/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_searching/searching_algorithm_revisited/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_searching/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/bubble_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/bucket_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/counting_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/heap_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/insertion_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/merge_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/quick_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/radix_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/selection_sort/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/sorting_algorithm/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_sorting/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_stack_and_queue/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_stack_and_queue/deque/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_stack_and_queue/queue/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_stack_and_queue/stack/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_stack_and_queue/summary/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_tree/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_tree/array_representation_of_tree/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_tree/avl_tree/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_tree/binary_search_tree/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_tree/binary_tree/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_tree/binary_tree_traversal/ - 2024-04-01 + 2024-04-02 daily https://www.hello-algo.com/chapter_tree/summary/ - 2024-04-01 + 2024-04-02 daily \ No newline at end of file diff --git a/sitemap.xml.gz b/sitemap.xml.gz index 798f15d7e26e7d4aaeb24081adc93166f5e0a2fc..34ac1b89a0d636b6de48686c6bef7680d9b7f260 100644 GIT binary patch literal 1004 zcmV6y%1K}edZ$DtWlaADLn9GX)Mp0~N@6-9x!KQ5zrI&p~F*|*i#^~>ss zt#nG;{%!U1-+!LJuYT;lY;!P?(^F||{Gas9Pz;1K94$SPs9J+Lx5COqJ&5)XU66_|aFNgZgMsw90|Cn6fBBiBC@yd zP0GDrw1do4GJMeq6uK;e!c;vu_P{bvt1L`mis9~E7|BW&d?J(EkI#QAOY~HvKvyql zgHC#c839F!L`)&elmjE7b`-UoE7R3;L}D-1W$LPbc+W>c(HD%U_gc;qfZGFWk_4h=8EO55VVvlF(78NKHd~Dr@%6xwh@j2i}up z2uA8$P9hB~V7fKtzUSC};^xlVzBeeS#lzahm3H31Zhhf(r+nCVM`RYPdWHnoHgae_ z@VV0m_NE?stXqr}M0bVAG2HoYclT67aVjTW-!xPxG5|R0=t622*N85 z_3Z%^Ug@%(vb!+Eb>WOddz(XWkVg(Zki{LdmIoZ%KuTY5a3dR*So*tMLG~+d)Chq? zs$0hOB;+x3W++z0M=)Z%KAy^0!~j-TPpY>MIKSOqmY{(n+jM&+288}(Ku8}`6j01? aupnpUChY&rlTDY%Y4;0Cm>B0*N&o<5EZkQB literal 1004 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 literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/heap_push_step9.png b/en/chapter_heap/heap.assets/heap_push_step9.png new file mode 100644 index 0000000000000000000000000000000000000000..8f26a52ca002b06a14c107d5cb87b0d0ba515fdf GIT binary patch literal 23567 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 z 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 Kldq6P1^x%kmAG&K literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap.assets/min_heap_and_max_heap.png b/en/chapter_heap/heap.assets/min_heap_and_max_heap.png new file mode 100644 index 0000000000000000000000000000000000000000..799f85c75f53666793fe48dba3c27bc171bb1ad0 GIT binary patch literal 22098 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 S2WWY{&%E)YF%CJdG`iCK4=jT{P+>s?F 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 l07*Dp_p=fS?83{1OQ8uO*sGn literal 0 HcmV?d00001 diff --git a/en/chapter_heap/heap/index.html b/en/chapter_heap/heap/index.html new file mode 100644 index 000000000..af0dd868f --- /dev/null +++ b/en/chapter_heap/heap/index.html @@ -0,0 +1,4134 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 8.1 Heap - Hello Algo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +